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à. # Formazione distribuita in Amazon SageMaker AI SageMaker L'intelligenza artificiale fornisce librerie di formazione distribuite e supporta varie opzioni di formazione distribuite per attività di deep learning come la visione artificiale (CV) e l'elaborazione del linguaggio naturale (NLP). Con le librerie di formazione distribuite di SageMaker AI, puoi eseguire in parallelo dati personalizzati altamente scalabili ed economici e modellare lavori di formazione paralleli di deep learning. Puoi anche utilizzare altri framework e pacchetti di formazione distribuiti come PyTorch DistributedDataParallel (DDP)`torchrun`, MPI () e parameter server. `mpirun` Nella sezione seguente vengono fornite informazioni sui concetti fondamentali dell’addestramento distribuito. In tutta la documentazione, le istruzioni e gli esempi si concentrano su come configurare le opzioni di formazione distribuite per le attività di deep learning utilizzando SageMaker Python SDK. **Suggerimento** Per conoscere le migliori pratiche per il calcolo dei processi di addestramento distribuito ed elaborazione del machine learning (ML) in generale, consulta [Elaborazione distribuita con best practice di SageMaker intelligenza artificiale](distributed-training-options.md). ## Concetti di addestramento distribuito SageMaker Le librerie di formazione distribuite di AI utilizzano i seguenti termini e funzionalità di formazione distribuita. **Set di dati e batch** + **Set di dati di addestramento**: tutti i dati utilizzati per addestrare il modello. + **Dimensione globale del batch**: il numero di record selezionati dal set di dati di addestramento in ogni iterazione da inviare al GPUs cluster. Questo è il numero di record su cui viene calcolato il gradiente a ogni iterazione. Se viene utilizzato il parallelismo dei dati, esso è uguale al numero totale di repliche del modello moltiplicato per la dimensione del batch per replica: `global batch size = (the number of model replicas) * (per-replica batch size)`. Un singolo batch di dimensioni globali viene spesso definito *mini-batch* nella letteratura sul machine learning. + **Dimensione del batch per replica**: quando si utilizza il parallelismo dei dati, si tratta del numero di record inviati a ciascuna replica del modello. Ogni replica del modello esegue un passaggio avanti e indietro con questo batch per calcolare gli aggiornamenti del peso. Gli aggiornamenti di peso risultanti vengono sincronizzati (ne viene calcolata la media) su tutte le repliche prima dell'elaborazione del set successivo di batch per replica. + **Microbatch**: un sottoinsieme del mini-batch o, se si utilizza un modello ibrido e il parallelismo dei dati, si tratta di un sottoinsieme del batch delle dimensioni di una singola replica. Quando si utilizza la libreria di parallelismo di modelli distribuiti di SageMaker AI, ogni microbatch viene inserito nella pipeline di addestramento one-by-one e segue un [programma di esecuzione](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-pipeline-execution) definito dal runtime della libreria. **Addestramento** + **Epoca**: un ciclo di addestramento sull'intero set di dati. È comune avere più iterazioni per epoca. Il numero di epoche utilizzate durante l'addestramento dipende dal modello e dal caso d'uso. + **Iterazione**: un singolo passaggio in avanti e all'indietro eseguito utilizzando un batch globale di dati di addestramento delle dimensioni di un batch (un mini-batch). Il numero di iterazioni eseguite durante l'addestramento è determinato dalla dimensione globale del batch e dal numero di epoche utilizzate per l'addestramento. Ad esempio, se un set di dati include 5.000 campioni e si utilizza un batch globale di 500, saranno necessarie 10 iterazioni per completare una singola epoca. + **Tasso di apprendimento**: variabile che influenza la quantità di pesi modificati in risposta all'errore calcolato del modello. Il tasso di apprendimento svolge un ruolo importante nella capacità del modello di convergere, nonché nella velocità e nell'ottimalità della convergenza. **Istanze e GPUs** + **Istanze**: un'istanza di [calcolo AWS per l'apprendimento automatico](https://aws.amazon.com/sagemaker/pricing/). Vengono anche chiamate *nodi*. + **Dimensione del cluster**: quando si utilizza la libreria di formazione distribuita di SageMaker AI, questo è il numero di istanze moltiplicato per il numero di GPU in ciascuna istanza. Ad esempio, se si utilizzano due istanze ml.p3.8xlarge in un processo di addestramento, con 4 GPU ciascuna, la dimensione del cluster è 8. Sebbene l'aumento delle dimensioni del cluster possa portare a tempi di addestramento più rapidi, la comunicazione tra le istanze deve essere ottimizzata; in caso contrario, la comunicazione tra i nodi può aumentare il sovraccarico di lavoro e comportare tempi di addestramento più lunghi. La libreria di formazione distribuita SageMaker AI è progettata per ottimizzare la comunicazione tra le istanze di calcolo ML di Amazon EC2, con conseguente maggiore utilizzo dei dispositivi e tempi di formazione più rapidi. **Soluzioni di addestramento distribuito** + **Parallelismo dei dati**: una strategia di addestramento distribuito in cui un set di dati di addestramento viene suddiviso su più GPU in un cluster di elaborazione, composto da più istanze ML di Amazon EC2. Ogni GPU contiene una *replica* del modello, riceve diversi batch di dati di addestramento, esegue un passaggio avanti e indietro e condivide gli aggiornamenti di peso con gli altri nodi per la sincronizzazione prima di passare al batch successivo e, infine, a un'altra epoca. + **Parallelismo dei modelli**: una strategia di addestramento distribuito in cui il modello è partizionato su più GPU in un cluster di elaborazione, composto da più istanze ML di Amazon EC2. Il modello potrebbe essere complesso e avere un gran numero di livelli e pesi nascosti, il che lo rende incapace di adattarsi alla memoria di una singola istanza. Ciascuna GPU contiene un sottoinsieme del modello, attraverso il quale i flussi di dati e le trasformazioni vengono condivisi e compilati. L'efficienza del parallelismo dei modelli, in termini di utilizzo della GPU e tempi di addestramento, dipende in larga misura dal modo in cui il modello è partizionato e dalla pianificazione di esecuzione utilizzata per eseguire i passaggi avanti e indietro. + **Pianificazione dell'esecuzione della pipeline** (**pipelining**): la pianificazione di esecuzione della pipeline determina l'ordine in cui vengono eseguiti i calcoli (microbatch) e i dati vengono elaborati tra i dispositivi durante l'addestramento del modello. Il pipelining è una tecnica per ottenere una vera parallelizzazione nel parallelismo dei modelli e superare la perdita di prestazioni dovuta al calcolo sequenziale eseguendo il calcolo simultaneo su diversi campioni di dati. GPUs Per ulteriori informazioni, consulta [Pipeline Execution Schedule](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-pipeline-execution). ### Concetti avanzati I professionisti del Machine Learning (ML) di solito devono affrontare due sfide di scalabilità quando addestrano i modelli: *scalare le dimensioni del modello* e *scalare i dati di addestramento*. Sebbene le dimensioni e la complessità del modello possano portare a una maggiore precisione, esiste un limite alle dimensioni del modello che è possibile inserire in una singola CPU o GPU. Inoltre, la scalabilità delle dimensioni del modello può comportare un numero maggiore di calcoli e tempi di addestramento più lunghi. Non tutti i modelli gestiscono la scalabilità dei dati di addestramento allo stesso modo, poiché per l'addestramento devono inserire tutti i dati di addestramento *in memoria*. Si scalano solo verticalmente e per tipi di istanze sempre più grandi. Nella maggior parte dei casi, la scalabilità dei dati di addestramento comporta tempi di addestramento più lunghi. Deep Learning (DL) è una famiglia specifica di algoritmi ML composta da diversi livelli di reti neurali artificiali. Il metodo di addestramento più comune è la discesa stocastica del gradiente (SGD) in mini-batch. Nella SGD in mini-batch, il modello viene addestrato effettuando piccole modifiche iterative dei suoi coefficienti nella direzione che ne riduce l'errore. Tali iterazioni vengono condotte su sottocampioni di uguali dimensioni del set di dati di addestramento chiamati *mini-batch.* Per ogni mini-batch, il modello viene eseguito in ogni record del mini-batch, ne viene misurato l'errore e viene stimato il gradiente dell'errore. Quindi, il gradiente medio viene misurato su tutti i record del mini-batch e fornisce una direzione di aggiornamento per ogni coefficiente del modello. Un passaggio completo sul set di dati di addestramento viene chiamato *epoca*. Gli addestramenti del modello consistono in genere in dozzine o centinaia di epoche. SGD in mini-Batch presenta diversi vantaggi: in primo luogo, il suo design iterativo rende il tempo di addestramento teoricamente lineare rispetto alla dimensione del set di dati. In secondo luogo, in un determinato mini-batch ogni record viene elaborato individualmente dal modello senza ricorrere a comunicazioni tra record diversi dalla media del gradiente finale. L'elaborazione di un mini-batch è quindi particolarmente adatta per la parallelizzazione e la distribuzione.  La parallelizzazione dell'addestramento SGD distribuendo i record di un mini-batch su diversi dispositivi di elaborazione è chiamata *addestramento distribuito parallelo* dei dati ed è il paradigma di distribuzione DL più comunemente usato. L'addestramento parallelo dei dati è una strategia di distribuzione pertinente per scalare le dimensioni dei mini-batch ed elaborare ogni mini-batch più velocemente. Tuttavia, l'addestramento parallelo dei dati comporta l'ulteriore complessità di dover calcolare la media del gradiente in mini-batch con i gradienti provenienti da tutti i worker e comunicarla a tutti i worker, una fase chiamata *allreduce* che può rappresentare un sovraccarico crescente, poiché il cluster di addestramento viene ridimensionato, e che può anche penalizzare drasticamente i tempi di addestramento se implementata in modo improprio o con sottrazioni hardware improprie.  L'SGD parallelo dei dati richiede comunque che gli sviluppatori siano in grado di inserire almeno il modello e un singolo record in un dispositivo di elaborazione, come una singola CPU o GPU. Quando si addestrano modelli molto grandi come trasformatori di grandi dimensioni in elaborazione del linguaggio naturale (NLP) o modelli di segmentazione su immagini ad alta risoluzione, potrebbero verificarsi situazioni in cui ciò non è possibile. Un modo alternativo per suddividere il carico di lavoro consiste nel partizionare il modello su più dispositivi di elaborazione, un approccio chiamato *addestramento distribuito parallelo al modello*. # Inizia con la formazione distribuita in Amazon SageMaker AI La pagina seguente fornisce informazioni sui passaggi necessari per iniziare con la formazione distribuita in Amazon SageMaker AI. Se conosci già l'addestramento distribuito, per iniziare scegli una delle seguenti opzioni corrispondente alla tua strategia o al tuo framework preferito. Se vuoi saperne di più sull'addestramento distribuito in generale, consulta [Concetti di addestramento distribuito](distributed-training.md#distributed-training-basic-concepts). Le librerie di formazione distribuite basate sull' SageMaker intelligenza artificiale sono ottimizzate per l'ambiente di SageMaker formazione, aiutano ad adattare i lavori di formazione distribuiti all' SageMaker intelligenza artificiale e migliorano la velocità e la produttività della formazione. Le librerie offrono strategie di addestramento con parallelismo dei dati e parallelismo dei modelli. Combinano tecnologie software e hardware per migliorare le comunicazioni tra GPU e tra nodi ed estendono le capacità di formazione dell' SageMaker IA con opzioni integrate che richiedono modifiche minime al codice degli script di formazione.  ## Prima di iniziare SageMaker La formazione supporta la formazione distribuita su una singola istanza e su più istanze, in modo da poter eseguire corsi di formazione di qualsiasi dimensione su larga scala. Ti consigliamo di utilizzare le classi di stima del framework come [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator)e [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)nell'SDK SageMaker Python, che sono i lanciatori di lavori di formazione con varie opzioni di formazione distribuite. Quando crei un oggetto estimatore, l'oggetto configura un'infrastruttura di formazione distribuita, esegue l'`CreateTrainingJob`API nel backend, trova la regione in cui è in esecuzione la sessione corrente e richiama uno dei contenitori di AWS deep learning predefiniti preconfezionati con una serie di librerie tra cui framework di deep learning, framework di formazione distribuiti e il driver [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). Se desideri montare un FSx file system sulle istanze di addestramento, devi passare l'ID della sottorete VPC e del gruppo di sicurezza allo estimatore. Prima di eseguire il tuo processo di formazione distribuito in SageMaker AI, leggi le seguenti linee guida generali sulla configurazione di base dell'infrastruttura. ### Zone di disponibilità e backplane di rete Quando utilizzi più istanze (chiamate anche *nodi*), è importante comprendere la rete che le collega, come leggono i dati di addestramento e come condividono le informazioni tra di loro. Ad esempio, quando esegui un processo di formazione distribuito in parallelo ai dati, diversi fattori, come la comunicazione tra i nodi di un cluster di calcolo per l'esecuzione dell'`AllReduce`operazione e il trasferimento dei dati tra i nodi e l'archiviazione dei dati in Amazon Simple Storage Service o Amazon FSx for Lustre, svolgono un ruolo cruciale per ottenere un uso ottimale delle risorse di elaborazione e una maggiore velocità di formazione. Per ridurre il sovraccarico di comunicazione, assicurati di configurare le istanze, la sottorete VPC e lo storage dei dati nella stessa zona di disponibilità. Regione AWS ### Istanze GPU con rete più veloce e archiviazione ad alto throughput Dal punto di vista tecnico, è possibile utilizzare qualsiasi istanza per l'addestramento distribuito. [Nei casi in cui è necessario eseguire lavori di formazione distribuiti su più nodi per addestrare modelli di grandi dimensioni, come modelli di linguaggio di grandi dimensioni (LLMs) e modelli di diffusione, che richiedono una commutazione tra nodi più rapida, consigliamo istanze GPU abilitate per EFA supportate dall'intelligenza artificiale. SageMaker ](https://aws.amazon.com/about-aws/whats-new/2021/05/amazon-sagemaker-supports-elastic-fabric-adapter-distributed-training/) [In particolare, per ottenere il training distribuito più efficiente possibile in materia di SageMaker intelligenza artificiale, consigliamo le istanze P4d e P4de dotate di NVIDIA A100. GPUs](https://aws.amazon.com/ec2/instance-types/p4/) Queste sono inoltre dotate di archiviazione di istanze locale ad alto throughput e bassa latenza e di una rete intra-nodo più veloce. Per l'archiviazione dei dati, consigliamo [Amazon FSx for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html), che offre un throughput elevato per l'archiviazione di set di dati di addestramento e checkpoint dei modelli. **Usa la libreria SageMaker AI Distributed Data Parallelism (SMDDP)** La libreria SMDDP migliora la comunicazione tra i nodi con implementazioni `AllReduce` e operazioni di comunicazione `AllGather` collettiva ottimizzate per l'infrastruttura di AWS rete e la topologia delle istanze Amazon SageMaker AI ML. [È possibile utilizzare la [libreria SMDDP come backend di pacchetti di formazione distribuiti PyTorch basati su: distributed PyTorch ](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-modify-sdp-pt.html)[data parallel (DDP), PyTorch Fully Sharded Data](https://pytorch.org/docs/stable/notes/ddp.html)[Parallelism (FSDP](https://pytorch.org/docs/stable/fsdp.html)) e Megatron-. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed) Il seguente esempio di codice mostra come impostare uno strumento di stima `PyTorch` per l’avvio di un job di addestramento distribuito su due istanze `ml.p4d.24xlarge`. ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( ..., instance_count=2, instance_type="ml.p4d.24xlarge", # Activate distributed training with SMDDP distribution={ "pytorchddp": { "enabled": True } } # mpirun, activates SMDDP AllReduce OR AllGather # distribution={ "torch_distributed": { "enabled": True } } # torchrun, activates SMDDP AllGather # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } # mpirun, activates SMDDP AllReduce OR AllGather ) ``` Per informazioni su come preparare lo script di formazione e avviare un processo di formazione distribuito in parallelo con i dati sull' SageMaker intelligenza artificiale, consulta. [Esegui corsi di formazione distribuiti con la libreria di parallelismo dei dati distribuiti basata sull' SageMaker intelligenza artificiale](data-parallel.md) **Usa la libreria di parallelismo dei modelli SageMaker AI (SMP)** SageMaker L'intelligenza artificiale fornisce la libreria SMP e supporta varie tecniche di formazione distribuite, come il parallelismo dei dati condivisi, il pipelining, il parallelismo tensoriale, lo sharding dello stato dell'ottimizzatore e altro ancora. Per saperne di più su ciò che offre la libreria SMP, consulta [Caratteristiche principali della SageMaker Model Parallelism Library](model-parallel-core-features.md). Per utilizzare la libreria di parallelismo dei modelli di SageMaker AI, configura il parametro degli stimatori del framework AI. `distribution` SageMaker Gli stimatori di framework supportati sono e. [PyTorch[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) L'esempio di codice seguente mostra come costruire uno strumento di valutazione del framework per l'addestramento distribuito con la libreria di parallelismo dei modelli su due istanze `ml.p4d.24xlarge`. ``` from sagemaker.framework import Framework distribution={ "smdistributed": { "modelparallel": { "enabled":True, "parameters": { ... # enter parameter key-value pairs here } }, }, "mpi": { "enabled" : True, ... # enter parameter key-value pairs here } } estimator = Framework( ..., instance_count=2, instance_type="ml.p4d.24xlarge", distribution=distribution ) ``` Per scoprire come adattare lo script di formazione, configurare i parametri di distribuzione nella `estimator` classe e avviare un processo di formazione distribuito, consulta la [libreria di parallelismo dei modelli di SageMaker AI](model-parallel.md) (vedi anche [Distributed Training APIs nella documentazione](https://sagemaker.readthedocs.io/en/stable/api/training/distributed.html#the-sagemaker-distributed-model-parallel-library) di *SageMaker Python* SDK). **Utilizzo di framework di addestramento distribuito open source** SageMaker L'intelligenza artificiale supporta anche le seguenti opzioni operative `mpirun` e `torchrun` nel backend. + Per utilizzare [PyTorch DistributedDataParallel (DDP)](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html) nell' SageMaker intelligenza artificiale con il `mpirun` backend, aggiungilo `distribution={"pytorchddp": {"enabled": True}}` al tuo estimatore. PyTorch Per ulteriori informazioni, consulta anche l'`distribution`argomento di [PyTorch Distributed Training](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#distributed-pytorch-training) e [SageMaker AI PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) nella documentazione di *SageMaker Python SDK*. **Nota** Questa opzione è disponibile per PyTorch 1.12.0 e versioni successive. ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( ..., instance_count=2, instance_type="ml.p4d.24xlarge", distribution={"pytorchddp": {"enabled": True}} # runs mpirun in the backend ) ``` + SageMaker [L'intelligenza artificiale supporta il [PyTorch `torchrun`launcher](https://pytorch.org/docs/stable/elastic/run.html) per la formazione distribuita su istanze Amazon EC2 basate su GPU, come P3 e P4, oltre a Trn1 alimentato dal dispositivo Trainium.AWS](https://aws.amazon.com/machine-learning/trainium/) Per utilizzare [PyTorch DistributedDataParallel (DDP)](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html) nell'IA con il backend, aggiungilo allo estimatore. SageMaker `torchrun` `distribution={"torch_distributed": {"enabled": True}}` PyTorch **Nota** Questa opzione è disponibile per PyTorch 1.13.0 e versioni successive. Il seguente frammento di codice mostra un esempio di creazione di uno PyTorch stimatore SageMaker AI per eseguire l'addestramento distribuito su due `ml.p4d.24xlarge` istanze con l'opzione di distribuzione. `torch_distributed` ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( ..., instance_count=2, instance_type="ml.p4d.24xlarge", distribution={"torch_distributed": {"enabled": True}} # runs torchrun in the backend ) ``` Per ulteriori informazioni, consulta l'`distribution`argomento di [Distributed PyTorch Training](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#distributed-pytorch-training) e [SageMaker AI PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) nella documentazione di *SageMaker Python SDK*. **Note per l'addestramento distribuito su Trn1** Un'istanza Trn1 è composta da un massimo di 16 dispositivi Trainium e ogni dispositivo Trainium è composto da due. [NeuronCores](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/neuron-hardware/neuroncores-arch.html#neuroncores-v2-arch) *Per le specifiche dei dispositivi Trainium, consulta AWS [Trainium](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/neuron-hardware/trn1-arch.html#id2) Architecture nella documentazione di Neuron.AWS * Per eseguire l'addestramento sulle istanze basate su Trainium, è sufficiente specificare il codice dell'istanza Trn1, in stringa`ml.trn1.*`, all'argomento della classe di stima AI. `instance_type` SageMaker PyTorch Per trovare i tipi di istanza Trn1 disponibili, consulta [AWS Trn1 Architecture](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/neuron-hardware/trn1-arch.html#aws-trn1-arch) nella documentazione di *AWS Neuron*. **Nota** SageMaker La formazione sulle istanze Amazon EC2 Trn1 è attualmente disponibile solo per il PyTorch framework nei AWS Deep Learning Containers for Neuron a partire dalla versione 1.11.0. PyTorch Per trovare un elenco completo delle versioni supportate di PyTorch Neuron, consulta [Neuron Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) nel repository *AWS Deep Learning Containers GitHub *. Quando avvii un processo di formazione su istanze Trn1 utilizzando l'SDK SageMaker Python, l' SageMaker intelligenza artificiale preleva ed esegue automaticamente il contenitore giusto da Neuron Containers [fornito](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) da Deep Learning Containers. AWS I Neuron Containers sono preconfezionati con impostazioni e dipendenze dell'ambiente di formazione per adattare più facilmente il lavoro di formazione alla piattaforma di formazione e alle istanze SageMaker Amazon EC2 Trn1. **Nota** [Per eseguire il processo di PyTorch formazione su istanze Trn1 con SageMaker AI, è necessario modificare lo script di formazione per inizializzare i gruppi di processi con il backend e utilizzare /XLA. `xla` PyTorch](https://pytorch.org/xla/release/1.12/index.html) Per supportare il processo di adozione di XLA, l'SDK Neuron fornisce AWS PyTorch Neuron che utilizza XLA per effettuare la conversione delle operazioni in istruzioni Trainium. PyTorch *Per informazioni su come modificare lo script di allenamento, consulta la [Guida per gli sviluppatori per l'allenamento con PyTorch Neuron () nella documentazione di Neuron. `torch-neuronx`](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/frameworks/torch/torch-neuronx/programming-guide/training/pytorch-neuron-programming-guide.html)AWS * *Per ulteriori informazioni, consulta [Distributed Training with PyTorch Neuron sulle istanze Trn1](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id24) e l'argomento di [SageMaker AI PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) `distribution` nella documentazione di Python SDK. SageMaker * + Per utilizzare MPI nell'intelligenza artificiale, aggiungilo al tuo estimatore. SageMaker `distribution={"mpi": {"enabled": True}}` L'opzione di distribuzione MPI è disponibile per i seguenti framework:,, e. MXNet PyTorch TensorFlow + Per utilizzare un server di parametri in SageMaker AI, aggiungilo `distribution={"parameter_server": {"enabled": True}}` al tuo estimatore. L'opzione del server dei parametri è disponibile per i seguenti framework: MXNet,, PyTorch e. TensorFlow **Suggerimento** Per ulteriori informazioni sull'utilizzo delle opzioni MPI e del server dei parametri per framework, utilizzate i seguenti collegamenti alla documentazione di *SageMaker Python SDK*. [MXNet Distributed Training e l'argomentazione](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#distributed-training) di [SageMaker AI MXNet ](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html#mxnet-estimator) Estimator `distribution` [PyTorch Distributed Training](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#distributed-pytorch-training) e [SageMaker argomentazione di AI PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) `distribution` [TensorFlow Distributed Training](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#distributed-training) e [SageMaker argomentazione di AI TensorFlow Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator). `distribution` # Strategie per l’addestramento distribuito L'addestramento distribuito è generalmente suddiviso in due approcci: parallelo ai dati e parallelo al modello. Il *data parallel* è l'approccio più comune all'addestramento distribuito: disponi di molti dati, li raggruppi in batch e invii blocchi di dati a più CPUs o GPUs (nodi) per essere elaborati dalla rete neurale o dall'algoritmo ML, quindi combini i risultati. La rete neurale è la stessa su ogni nodo. L'approccio *parallelo al modello* viene utilizzato con modelli di grandi dimensioni che non entrano nella memoria di un nodo in un unico pezzo; suddivide il modello e posiziona parti diverse su nodi diversi. In questa situazione, è necessario inviare i batch di dati a ciascun nodo in modo che essi vengano elaborati su tutte le parti del modello. I termini *rete* e *modello* sono spesso usati in modo intercambiabile: un modello di grandi dimensioni è in realtà una grande rete con molti livelli e parametri. L'addestramento con una rete di grandi dimensioni produce un modello di grandi dimensioni, mentre il caricamento del modello sulla rete con tutti i parametri pre-addestrati e i relativi pesi carica in memoria un modello di grandi dimensioni. Quando si scompone un modello per dividerlo tra i nodi, si scompone anche la rete sottostante. Una rete è composta da livelli e, per suddividere la rete, si inseriscono livelli su diversi dispositivi di elaborazione. Un problema comune della suddivisione ingenua dei livelli tra i dispositivi è il grave sottoutilizzo della GPU. L'addestramento è intrinsecamente sequenziale sia nei passaggi in avanti che in quelli all'indietro e, in un dato momento, solo una GPU può eseguire il calcolo attivo, mentre le altre GPU attendono l'invio delle attivazioni. Le moderne librerie di parallelismo dei modelli risolvono questo problema utilizzando pianificazioni di esecuzione della pipeline per migliorare l'utilizzo dei dispositivi. Tuttavia, solo la libreria parallela di modelli distribuiti di Amazon SageMaker AI include la suddivisione automatica del modello. Le due funzionalità principali della libreria, la suddivisione automatica dei modelli e la pianificazione dell'esecuzione della pipeline, semplificano il processo di implementazione del parallelismo dei modelli prendendo decisioni automatizzate che determinano un utilizzo efficiente dei dispositivi. ## Addestramento con approccio parallelo ai dati e parallelo al modello Se ti stai addestrando con un set di dati di grandi dimensioni, inizia con un approccio parallelo ai dati. Se esaurisci la memoria durante l'addestramento, potrebbe essere opportuno passare a un approccio parallelo al modello oppure provare il parallelismo ibrido tra modelli e dati. Inoltre, puoi anche provare quanto segue per migliorare le prestazioni con l'approccio parallelo ai dati: + Modificare gli iperparametri del modello. + Ridurre le dimensioni del batch. + Continua a ridurre le dimensioni del batch finché non si adattano. Se riduci le dimensioni del batch a 1 e continui a esaurire la memoria, dovresti provare l'addestramento parallelo al modello. Prova la compressione a gradiente (FP16,): INT8 + Sull'hardware TensorCore dotato di NVIDIA, l'utilizzo di un [training di precisione misto](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html) consente di velocizzare e ridurre il consumo di memoria. + SageMaker La libreria di parallelismo dei dati distribuito di AI supporta immediatamente Automatic Mixed Precision (AMP). Non è necessaria alcuna azione aggiuntiva per abilitare AMP oltre alle modifiche a livello di framework allo script di addestramento. Se i gradienti sono presenti FP16, la libreria di parallelismo dei dati SageMaker AI esegue il suo funzionamento in. `AllReduce` FP16 Per ulteriori informazioni sull'implementazione di AMP nello script APIs di formazione, consulta le seguenti risorse: + [Frameworks: PyTorch nella documentazione](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#pytorch) di *NVIDIA Deep* Learning Performance + [Frameworks: TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) *nella documentazione di NVIDIA Deep Learning Performance* + [Automatic mixed precision for deep learning](https://developer.nvidia.com/automatic-mixed-precision) nella *documentazione per sviluppatori NVIDIA* + [https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/) + [TensorFlow precisione mista APIs](https://www.tensorflow.org/guide/mixed_precision) *nella documentazione TensorFlow* Prova a ridurre la dimensione di input: + Riduci la lunghezza della sequenza NLP se aumenti il collegamento della sequenza, devi ridurre la dimensione del batch o aumentarla per distribuire il batch. GPUs + Riduzione della risoluzione delle immagini. Controlla se utilizzi la normalizzazione in batch, in quanto ciò può influire sulla convergenza. Quando si utilizza la formazione distribuita, il batch viene suddiviso in più parti GPUs e l'effetto di una dimensione del batch molto inferiore può comportare un tasso di errore più elevato, interrompendo così la convergenza del modello. Ad esempio, se avete prototipato la rete su una singola GPU con una dimensione batch di 64 e poi scalata fino a utilizzare quattro p3dn.24xlarge, ora ne avete 32 GPUs e la dimensione del batch per GPU scende da 64 a 2. Ciò probabilmente interromperà la convergenza osservata con un singolo nodo. Inizia con l'addestramento parallelo al modello quando: + Il tuo modello non si adatta a un singolo dispositivo. + A causa delle dimensioni del modello, la scelta di batch di dimensioni maggiori è limitata, ad esempio se i pesi dei modelli occupano la maggior parte della memoria della GPU e sei costretto a scegliere un batch di dimensioni inferiori e non ottimali.  Per ulteriori informazioni sulle librerie distribuite di intelligenza artificiale, consulta quanto segue: SageMaker + [Esegui corsi di formazione distribuiti con la libreria di parallelismo dei dati distribuiti basata sull' SageMaker intelligenza artificiale](data-parallel.md) + [(Archiviata) Libreria SageMaker Model Parallelism v1.x](model-parallel.md) # Ottimizzazione dell’addestramento distribuito Personalizza gli iperparametri in base al tuo caso d'uso e ai tuoi dati per ottenere la massima efficienza di scalabilità. Nella discussione che segue, evidenziamo alcune delle variabili di formazione più importanti e forniamo riferimenti alle state-of-the-art implementazioni in modo che possiate saperne di più sulle opzioni a vostra disposizione. Inoltre, ti consigliamo di fare riferimento alla documentazione di addestramento distribuita del tuo framework preferito. + [Formazione distribuita con Apache MXNet ](https://mxnet.apache.org/versions/1.7/api/faq/distributed_training) + [PyTorch formazione distribuita](https://pytorch.org/tutorials/beginner/dist_overview.html) + [TensorFlow formazione distribuita](https://www.tensorflow.org/guide/distributed_training) ## Dimensione batch SageMaker I toolkit distribuiti di intelligenza artificiale generalmente consentono di allenarsi su lotti più grandi. Ad esempio, se un modello si adatta a un singolo dispositivo, ma può essere addestrato solo con batch di piccole dimensioni, l'utilizzo dell'addestramento con approccio parallelo al modello o parallelo ai dati consente di sperimentare batch di dimensioni maggiori. Tieni presente che la dimensione del batch influenza direttamente la precisione del modello controllando la quantità di disturbo nell'aggiornamento del modello a ogni iterazione. L'aumento delle dimensioni del batch riduce la quantità di disturbo nella stima del gradiente, il che può essere utile quando si passa da batch di dimensioni molto piccole, ma può comportare una riduzione della precisione del modello man mano che la dimensione del batch aumenta fino a valori elevati.  **Suggerimento** Modifica gli iperparametri per assicurarti che il modello raggiunga una convergenza soddisfacente man mano che aumenti le dimensioni del batch. Sono state sviluppate diverse tecniche per mantenere una buona convergenza dei modelli quando si aumenta il numero di batch. ## Dimensioni del mini-batch In SGD, le dimensioni del mini-batch quantificano la quantità di disturbo presente nella stima del gradiente. Un mini-batch piccolo produce un gradiente di mini-batch con molto disturbo, che non è rappresentativo del gradiente reale sul set di dati. Un mini-batch grande produce un gradiente in mini-batch simile al gradiente reale sul set di dati e potenzialmente con un disturbo insufficiente, che probabilmente rimarrà bloccato in minimi irrilevanti. Per ulteriori informazioni su queste tecniche, consulta i seguenti documenti: + [Minibatch accurato e di grandi dimensioni SGD: ImageNet ](https://arxiv.org/pdf/1706.02677.pdf) addestramento in 1 ora, Goya et al. + [PowerAI DDL](https://arxiv.org/pdf/1708.02188.pdf), Cho et al. + [Scalabilità orizzontale per Minibatch di grandi dimensioni SGD: formazione residua in rete su ImageNet -1K con maggiore precisione e tempi di formazione ridotti](https://arxiv.org/pdf/1711.04291.pdf), Codreanu et al. + [ImageNet Allenamento in pochi minuti, You et al.](https://arxiv.org/pdf/1709.05011.pdf) + [Large Batch Training of Convolutional Networks](https://arxiv.org/pdf/1708.03888.pdf), You et al. + [Large Batch Optimization for Deep Learning: Training BERT in 76 Minutes](https://arxiv.org/pdf/1904.00962.pdf), You et al. + [Accelerated Large Batch Optimization of BERT Pretraining in 54 minutes](https://arxiv.org/pdf/2006.13484.pdf), Zheng et al. + [Deep Gradient Compression](https://arxiv.org/abs/1712.01887), Lin et al. # Dimensionamento delle risorse di addestramento Le sezioni seguenti illustrano gli scenari in cui potresti voler ampliare la formazione e come farlo utilizzando AWS le risorse. È possibile che sia necessario scalare l’addestramento in una delle seguenti situazioni: + Scalabilità da una singola GPU a molte GPUs + Scalabilità da una singola istanza a più istanze + Utilizzo di script di addestramento personalizzati ## Scalabilità da una singola GPU a molte GPUs La quantità di dati o le dimensioni del modello utilizzato nel machine learning possono creare situazioni in cui il tempo necessario per addestrare un modello è più lungo di quanto si sia disposti ad aspettare. A volte, l'addestramento non funziona affatto perché il modello o i dati di addestramento sono troppo grandi. Una soluzione consiste nell'aumentare il numero di utenti utilizzati per GPUs la formazione. In un'istanza con più istanze GPUs, ad esempio una `p3.16xlarge` che ne ha otto GPUs, i dati e l'elaborazione vengono suddivisi tra le otto istanze GPUs. Quando utilizzi librerie di addestramento distribuito, può verificarsi un'accelerazione quasi lineare del tempo necessario per addestrare il modello. Richiede poco più di 1/8 del tempo impiegato su `p3.2xlarge` con una sola GPU. | Tipo di istanza | GPUs | | --- | --- | | p3.2xlarge | 1 | | p3.8xlarge | 4 | | p3.16xlarge | 8 | | p3dn.24xlarge | 8 | **Nota** I tipi di istanze ml utilizzati dalla SageMaker formazione hanno lo stesso numero dei GPUs tipi di istanze p3 corrispondenti. Ad esempio, `ml.p3.8xlarge` ha lo stesso numero GPUs di `p3.8xlarge` - 4. ## Scalabilità da una singola istanza a più istanze Se desideri ampliare ulteriormente il tuo addestramento, puoi utilizzare più istanze. Tuttavia, dovresti scegliere un tipo di istanza più grande prima di aggiungere altre istanze. Consulta la tabella precedente per vedere quante ce ne GPUs sono in ogni tipo di istanza p3. Se sei passato da una singola GPU su una `p3.2xlarge` a quattro GPUs su una`p3.8xlarge`, ma decidi che hai bisogno di maggiore potenza di elaborazione, potresti ottenere prestazioni migliori e costi inferiori se scegli una `p3.16xlarge` prima di provare ad aumentare il numero di istanze. A seconda delle librerie utilizzate, se mantieni l'addestramento su una singola istanza, le prestazioni sono migliori e i costi sono inferiori rispetto a uno scenario in cui si utilizzano più istanze. Quando sei pronto per ridimensionare il numero di istanze, puoi farlo con la funzione SageMaker AI Python `estimator` SDK impostando il tuo. `instance_count` Ad esempio, puoi impostare `instance_type = p3.16xlarge` e `instance_count = 2`. Invece di otto GPUs su una singola istanza`p3.16xlarge`, ne hai 16 GPUs su due istanze identiche. Il grafico seguente mostra la [scalabilità e il throughput a partire da otto](https://aws.amazon.com/blogs/machine-learning/scalable-multi-node-training-with-tensorflow/) istanze GPUs su una singola istanza e aumentando fino a 64 istanze per un totale di 256. GPUs ![\[Chart showing how throughput increases and time to train decreases with more GPUs.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/Distributed-Training-in-SageMaker-image.png) ## Script di addestramento personalizzati L' SageMaker intelligenza artificiale semplifica l'implementazione e la scalabilità del numero di istanze e GPUs, a seconda del framework scelto, la gestione dei dati e dei risultati può essere molto impegnativa, motivo per cui vengono spesso utilizzate librerie di supporto esterne. Questa forma più elementare di formazione distribuita richiede la modifica dello script di formazione per gestire la distribuzione dei dati. SageMaker L'intelligenza artificiale supporta anche Horovod e le implementazioni di formazione distribuita native di ogni principale framework di deep learning. Se scegli di utilizzare esempi tratti da questi framework, puoi seguire la [guida ai container di SageMaker AI per Deep Learning Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html) e vari [taccuini di esempio](https://sagemaker-examples.readthedocs.io/en/latest/training/bring_your_own_container.html) che dimostrano le implementazioni. # Esegui corsi di formazione distribuiti con la libreria di parallelismo dei dati distribuiti basata sull' SageMaker intelligenza artificiale La libreria SageMaker AI Distributed Data Parallelism (SMDDP) estende le funzionalità di SageMaker formazione sui modelli di deep learning con un'efficienza di scalabilità quasi lineare fornendo implementazioni di operazioni di comunicazione collettiva ottimizzate per l'infrastruttura. AWS Quando si addestrano modelli di machine learning (ML) di grandi dimensioni, come modelli linguistici di grandi dimensioni (LLM) e modelli di diffusione, su un enorme set di dati di addestramento, i professionisti del machine learning utilizzano cluster di acceleratori e tecniche di addestramento distribuito per ridurre i tempi di addestramento o risolvere i vincoli di memoria per i modelli non adatti a ogni memoria GPU. I professionisti del machine learning spesso iniziano con più acceleratori su una singola istanza, per poi passare a cluster di istanze man mano che aumentano i requisiti del carico di lavoro. Quando aumentano le dimensioni del cluster, aumenta anche il sovraccarico di comunicazione tra più nodi, con un conseguente calo delle prestazioni di calcolo complessive. Per risolvere i problemi di sovraccarico e di memoria, la libreria SMDDP offre quanto segue. + La libreria SMDDP ottimizza i lavori di formazione per l'infrastruttura di AWS rete e la topologia delle istanze Amazon SageMaker AI ML. + La libreria SMDDP migliora la comunicazione tra i nodi con implementazioni `AllReduce` e operazioni di comunicazione `AllGather` collettiva ottimizzate per l'infrastruttura. AWS Per ulteriori informazioni sui dettagli delle offerte della libreria SMDDP, consulta [Introduzione alla libreria di parallelismo dei dati distribuiti per l' SageMaker intelligenza artificiale](data-parallel-intro.md). Per ulteriori informazioni sulla formazione con la strategia parallela a modelli offerta dall' SageMaker IA, consulta anche. [(Archiviata) Libreria SageMaker Model Parallelism v1.x](model-parallel.md) **Topics** + [Introduzione alla libreria di parallelismo dei dati distribuiti per l' SageMaker intelligenza artificiale](data-parallel-intro.md) + [Framework e tipi di Regioni AWS istanze supportati](distributed-data-parallel-support.md) + [Formazione distribuita con la libreria di parallelismo dei dati distribuiti SageMaker AI](data-parallel-modify-sdp.md) + [Esempi di librerie di parallelismo dei dati di Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) + [Suggerimenti di configurazione per la libreria di parallelismo dei dati distribuiti SageMaker AI](data-parallel-config.md) + [Domande frequenti sulla libreria Amazon SageMaker AI Distributed Data Parallelism](data-parallel-faq.md) + [Risoluzione dei problemi relativi alla formazione distribuita in Amazon SageMaker AI](distributed-troubleshooting-data-parallel.md) + [SageMaker Note di rilascio della libreria di parallelismo dei dati AI](data-parallel-release-notes.md) # Introduzione alla libreria di parallelismo dei dati distribuiti per l' SageMaker intelligenza artificiale La libreria SageMaker AI distributed data parallelism (SMDDP) è una libreria di comunicazione collettiva che migliora le prestazioni di calcolo dell'addestramento parallelo di dati distribuiti. La libreria SMDDP risponde al sovraccarico di comunicazioni delle principali operazioni di comunicazione collettiva offrendo quanto segue. 1. La libreria offre offerte ottimizzate per. `AllReduce` AWS`AllReduce`è un'operazione chiave utilizzata per sincronizzare i gradienti alla fine di ogni iterazione di addestramento durante l'addestramento distribuito dei dati. GPUs 1. La libreria offre offerte ottimizzate per. `AllGather` AWS`AllGather`è un'altra operazione chiave utilizzata nello sharded data parallel training, una tecnica di parallelismo dei dati efficiente in termini di memoria offerta da librerie popolari come la libreria SageMaker AI model parallelism (SMP), DeepSpeed Zero Redundancy Optimizer (Zero) e Fully Sharded Data Parallelism (FSDP). PyTorch 1. La libreria esegue node-to-node comunicazioni ottimizzate utilizzando appieno l'infrastruttura di AWS rete e la topologia dell'istanza Amazon EC2. La libreria SMDDP può incrementare la velocità di addestramento offrendo un miglioramento delle prestazioni allo scalare del cluster di addestramento, con un’efficienza di dimensionamento quasi lineare. **Nota** Le librerie di formazione distribuite sull' SageMaker intelligenza artificiale sono disponibili tramite i contenitori di AWS deep learning PyTorch e Hugging Face all'interno della piattaforma Training. SageMaker Per utilizzare le librerie, è necessario utilizzare SageMaker Python SDK o SageMaker APIs tramite SDK for Python (Boto3) o. AWS Command Line Interface In tutta la documentazione, le istruzioni e gli esempi si concentrano su come utilizzare le librerie di formazione distribuite con SageMaker Python SDK. ## Operazioni di comunicazione collettiva SMDDP ottimizzate per le risorse di AWS calcolo e l'infrastruttura di rete La libreria SMDDP fornisce implementazioni e operazioni `AllGather` collettive ottimizzate per AWS le risorse di calcolo `AllReduce` e l'infrastruttura di rete. ### Operazione collettiva `AllReduce` SMDDP La libreria SMDDP consente una sovrapposizione ottimale dell’operazione `AllReduce` con il passaggio indietro, migliorando significativamente l’utilizzo della GPU. Raggiunge un'efficienza di scalabilità quasi lineare e una maggiore velocità di addestramento ottimizzando le operazioni del kernel tra e. CPUs GPUs La libreria esegue `AllReduce` in parallelo mentre la GPU calcola i gradienti senza eliminare cicli della GPU aggiuntivi, consentendo alla libreria di conseguire un addestramento più rapido. + *Sfrutta CPUs*: La libreria utilizza due `AllReduce` gradienti, CPUs scaricando questa attività da. GPUs + *Utilizzo migliorato della GPU*: il cluster si GPUs concentra sul calcolo dei gradienti, migliorandone l'utilizzo durante l'allenamento. Di seguito è riportato il flusso di lavoro di alto livello dell’operazione `AllReduce` SMDDP. 1. La biblioteca assegna i gradi a (lavoratori). GPUs 1. Ad ogni iterazione, la libreria divide ogni batch globale per il numero totale di worker (dimensione mondiale) e assegna piccoli lotti (frammenti di batch) ai worker. + La dimensione del batch globale è `(number of nodes in a cluster) * (number of GPUs per node) * (per batch shard)`. + Un batch shard (small batch) è un sottoinsieme di set di dati assegnato a ciascuna GPU (worker) per iterazione. 1. La libreria lancia uno script di addestramento per ogni worker. 1. La libreria gestisce le copie dei pesi e dei gradienti dei modelli fornite dai worker alla fine di ogni iterazione. 1. La libreria sincronizza i pesi e i gradienti dei modelli tra i worker per aggregare un unico modello addestrato. Il seguente diagramma di architettura mostra un esempio di come la libreria imposta il parallelismo dei dati per un cluster di 3 nodi. ![\[Diagramma dell'architettura SMDDP AllReduce e del parallelismo dei dati\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/data-parallel/sdp-architecture.png) ### Operazione collettiva `AllGather` SMDDP `AllGather` è un’operazione collettiva in cui ogni worker inizia con un buffer di input e quindi concatena o *raccoglie* i buffer di input di tutti gli altri worker in un buffer di output. **Nota** L'operazione `AllGather` collettiva SMDDP è disponibile in AWS Deep Learning Containers (DLC) per PyTorch la versione 2.0.1 `smdistributed-dataparallel>=2.0.1` e successive. L’operazione `AllGather` è ampiamente diffusa nelle tecniche di addestramento distribuito come la parallelizzazione dei dati con sharding, in cui ogni singolo worker detiene una frazione di un modello o un livello con sharding. I worker chiamano `AllGather` prima dei passaggi avanti e indietro per ricostruire i livelli con sharding. I passaggi avanti e indietro continuano dopo *aver raccolto tutti* i parametri. Durante il passaggio indietro, ogni worker chiama `ReduceScatter` anche per raccogliere (ridurre) i gradienti e suddividerli in shard di gradienti per aggiornare il livello con sharding corrispondente. [Per maggiori dettagli sul ruolo di queste operazioni collettive nel parallelismo dei dati condivisi, consulta l'[implementazione del parallelismo dei dati condivisi da parte della libreria SMP, [Zero](https://deepspeed.readthedocs.io/en/latest/zero3.html#) nella documentazione e il blog su Fully Sharded Data Parallelism](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-sharded-data-parallelism.html). DeepSpeed PyTorch ](https://engineering.fb.com/2021/07/15/open-source/fsdp/) Poiché le operazioni collettive AllGather vengono richiamate in ogni iterazione, sono le principali responsabili del sovraccarico di comunicazione con la GPU. Un calcolo più rapido di queste operazioni collettive si traduce direttamente in un tempo di addestramento più breve, senza effetti collaterali sulla convergenza. A tal fine, la libreria SMDDP offre operazioni `AllGather` ottimizzate per le [istanze P4d](https://aws.amazon.com/ec2/instance-types/p4/). `AllGather` SMDDP utilizza le seguenti tecniche per migliorare le prestazioni di calcolo sulle istanze P4d. 1. Trasferisce dati tra istanze (tra nodi) tramite la rete [Elastic Fabric Adapter (EFA)](https://aws.amazon.com/hpc/efa/) con una topologia mesh. EFA è la soluzione di rete a AWS bassa latenza e ad alto throughput. Una topologia mesh per la comunicazione di rete tra nodi è più adatta alle caratteristiche dell'EFA e dell'infrastruttura di rete. AWS Rispetto alla topologia ad anello o ad albero di NCCL che prevede più hop di pacchetti, SMDDP evita l’accumulo di latenza da più hop, in quanto ne richiede solo uno. SMDDP implementa un algoritmo di controllo della velocità di rete che bilancia il carico di lavoro per ciascun peer di comunicazione in una topologia mesh e raggiunge un throughput di rete globale superiore. 1. Adotta una [libreria di copie di memoria GPU a bassa latenza basata sulla tecnologia NVIDIA GPUDirect RDMA](https://github.com/NVIDIA/gdrcopy) () per coordinare il traffico di rete locale ed EFA. GDRCopy NVLink GDRCopy, una libreria di copie di memoria GPU a bassa latenza offerta da NVIDIA, fornisce comunicazioni a bassa latenza tra i processi della CPU e i kernel GPU CUDA. Con questa tecnologia, la libreria SMDDP è in grado di eseguire in pipeline lo spostamento dei dati all’interno dei nodi e tra un nodo e l’altro. 1. Riduce l’utilizzo di multiprocessori di streaming sulla GPU per aumentare la potenza di calcolo per l’esecuzione dei kernel del modello. Le istanze P4d e P4de sono dotate di NVIDIA A100, ognuna con 108 multiprocessori di streaming. GPUs Mentre NCCL impiega fino a 24 multiprocessori di streaming per eseguire operazioni collettive, SMDDP ne utilizza meno di 9. I kernel di calcolo dei modelli raccolgono i multiprocessori di streaming salvati per un calcolo più rapido. # Framework e tipi di Regioni AWS istanze supportati Prima di utilizzare la libreria SageMaker AI Distributed Data Parallelism (SMDDP), controlla quali sono i framework ML e i tipi di istanze supportati e se ci sono quote sufficienti nel tuo account e. AWS Regione AWS ## Framework supportati Le tabelle seguenti mostrano i framework di deep learning e le relative versioni supportati da AI e SMDDP. SageMaker La libreria SMDDP è disponibile in [SageMaker AI Framework Containers, integrata nei contenitori](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) [Docker distribuiti dalla libreria SageMaker Model Parallelism (SMP)](distributed-model-parallel-support-v2.md#distributed-model-parallel-supported-frameworks-v2) v2 o scaricabile come file binario. **Nota** Per controllare gli aggiornamenti e le note di rilascio più recenti della libreria SMDDP, consulta [SageMaker Note di rilascio della libreria di parallelismo dei dati AI](data-parallel-release-notes.md). **Topics** + [PyTorch](#distributed-data-parallel-supported-frameworks-pytorch) + [PyTorch Lightning](#distributed-data-parallel-supported-frameworks-lightning) + [Trasformatori Hugging Face](#distributed-data-parallel-supported-frameworks-transformers) + [TensorFlow (obsoleto)](#distributed-data-parallel-supported-frameworks-tensorflow) ### PyTorch | PyTorch versione | Versione della libreria SMDDP | SageMaker immagini di AI Framework Container preinstallate con SMDDP | Immagini Docker SMP preinstallate con SMDDP | URL del file binario\$1\$1 | | --- | --- | --- | --- | --- | | v2.3.1 | smdistributed-dataparallel==v2.5.0 | Non disponibile | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.4.1/cu121/2024-10-09/smdistributed\$1dataparallel-2.5.0-cp311-cp311-linux\$1x86\$164.whl | | v2.3.0 | smdistributed-dataparallel==v2.3.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker | Attualmente non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed\$1dataparallel-2.3.0-cp311-cp311-linux\$1x86\$164.whl | | v2.2.0 | smdistributed-dataparallel==v2.2.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.2.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed\$1dataparallel-2.2.0-cp310-cp310-linux\$1x86\$164.whl | | v2.1.0 | smdistributed-dataparallel==v2.1.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed\$1dataparallel-2.1.0-cp310-cp310-linux\$1x86\$164.whl | | v2.0.1 | smdistributed-dataparallel==v2.0.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker | Non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed\$1dataparallel-2.0.2-cp310-cp310-linux\$1x86\$164.whl | | v2.0.0 | smdistributed-dataparallel==v1.8.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker | Non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.0/cu118/2023-03-20/smdistributed\$1dataparallel-1.8.0-cp310-cp310-linux\$1x86\$164.whl | | v1.13.1 | smdistributed-dataparallel==v1.7.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker | Non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.13.1/cu117/2023-01-09/smdistributed\$1dataparallel-1.7.0-cp39-cp39-linux\$1x86\$164.whl | | v1.12.1 | smdistributed-dataparallel==v1.6.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker | Non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.1/cu113/2022-12-05/smdistributed\$1dataparallel-1.6.0-cp38-cp38-linux\$1x86\$164.whl | | v1.12.0 | smdistributed-dataparallel==v1.5.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker | Non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.0/cu113/2022-07-01/smdistributed\$1dataparallel-1.5.0-cp38-cp38-linux\$1x86\$164.whl | | v1.11.0 | smdistributed-dataparallel==v1.4.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker | Non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.11.0/cu113/2022-04-14/smdistributed\$1dataparallel-1.4.1-cp38-cp38-linux\$1x86\$164.whl | \$1\$1 I file binari servono per l'installazione URLs della libreria SMDDP in contenitori personalizzati. Per ulteriori informazioni, consulta [Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI](data-parallel-bring-your-own-container.md). **Nota** La libreria SMDDP è disponibile Regioni AWS laddove sono in servizio i [contenitori SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) e le immagini [SMP Docker](distributed-model-parallel-support-v2.md). **Nota** La libreria SMDDP v1.4.0 e versioni successive funge da backend del parallelismo distribuito (torch.distributed) dei PyTorch dati (torch.parallel). DistributedDataParallel). In base alla modifica, i seguenti [smdistributed APIs](https://sagemaker.readthedocs.io/en/stable/api/training/sdp_versions/latest/smd_data_parallel_pytorch.html#pytorch-api) per il pacchetto PyTorch distribuito sono diventati obsoleti. `smdistributed.dataparallel.torch.distributed` è obsoleta. Utilizza invece il pacchetto [torch.distributed](https://pytorch.org/docs/stable/distributed.html). `smdistributed.dataparallel.torch.parallel.DistributedDataParallel` è obsoleta. [Usa torch.nn.parallel. DistributedDataParallel](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) API invece. *Se devi utilizzare le versioni precedenti della libreria (v1.3.0 o precedente), consulta la documentazione [archiviata sul parallelismo dei dati distribuiti SageMaker AI nella](https://sagemaker.readthedocs.io/en/stable/api/training/sdp_versions/latest.html#documentation-archive) documentazione di AI SageMaker Python SDK.* ### PyTorch Lightning La libreria SMDDP è disponibile per PyTorch Lightning nei seguenti contenitori SageMaker AI Framework Containers PyTorch e SMP Docker. **PyTorch Lightning v2** | PyTorch Versione Lightning | PyTorch versione | Versione della libreria SMDDP | SageMaker immagini di AI Framework Container preinstallate con SMDDP | Immagini Docker SMP preinstallate con SMDDP | URL del file binario\$1\$1 | | --- | --- | --- | --- | --- | --- | | 2.2.5 | 2.3.0 | smdistributed-dataparallel==v2.3.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker | Attualmente non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed\$1dataparallel-2.3.0-cp311-cp311-linux\$1x86\$164.whl | | 2.2.0 | 2.2.0 | smdistributed-dataparallel==v2.2.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.2.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed\$1dataparallel-2.2.0-cp310-cp310-linux\$1x86\$164.whl | | 2.1.2 | 2.1.0 | smdistributed-dataparallel==v2.1.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed\$1dataparallel-2.1.0-cp310-cp310-linux\$1x86\$164.whl | | 2.1.0 | 2.0.1 | smdistributed-dataparallel==v2.0.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker | Non disponibile | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed\$1dataparallel-2.0.2-cp310-cp310-linux\$1x86\$164.whl | **PyTorch Lightning v1** | PyTorch Versione Lightning | PyTorch versione | Versione della libreria SMDDP | SageMaker immagini di AI Framework Container preinstallate con SMDDP | URL del file binario\$1\$1 | | --- | --- | --- | --- | --- | | 1.7.2 1.7.0 1.6.4 1.6.3 1,5,10 | 1.12.0 | smdistributed-dataparallel==v1.5.0 | 763104351884.dkr.ecr. .amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.0/cu113/2022-07-01/smdistributed\$1dataparallel-1.5.0-cp38-cp38-linux\$1x86\$164.whl | \$1\$1 I file binari servono per l'installazione della libreria SMDDP in contenitori personalizzati. URLs Per ulteriori informazioni, consulta [Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI](data-parallel-bring-your-own-container.md). **Nota** PyTorch Lightning e le sue librerie di utilità come Lightning Bolts non sono preinstallate in. PyTorch DLCs Quando costruisci uno strumento di PyTorch valutazione dell' SageMaker intelligenza artificiale e invii una richiesta di lavoro di formazione nella [Fase 2](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-use-api.html#data-parallel-framework-estimator), devi provvedere all'installazione `pytorch-lightning` e `lightning-bolts` all'inserimento nel contenitore di formazione `requirements.txt` basato sull'intelligenza artificiale. SageMaker PyTorch ``` # requirements.txt pytorch-lightning lightning-bolts ``` Per ulteriori informazioni su come specificare la directory di origine in cui inserire il `requirements.txt` file insieme allo script di formazione e all'invio di un lavoro, consulta la sezione [Utilizzo di librerie di terze parti nella documentazione](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) di *Amazon AI SageMaker Python SDK*. ### Trasformatori Hugging Face I AWS Deep Learning Containers for Hugging Face utilizzano i SageMaker Training Containers per PyTorch e TensorFlow come immagini di base. [Per cercare le versioni della libreria Hugging Face Transformers e le versioni abbinate, TensorFlow consulta gli ultimi Hugging Face Containers PyTorch e le versioni precedenti di Hugging [Face](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) Container.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#prior-hugging-face-container-versions) ### TensorFlow (obsoleto) **Importante** La libreria SMDDP ha interrotto il supporto TensorFlow e non è più disponibile nelle versioni successive alla versione 2.11.0. DLCs TensorFlow Nella tabella seguente sono elencate le versioni precedenti con la libreria SMDDP DLCs installata TensorFlow . | TensorFlow versione | Versione della libreria SMDDP | | --- | --- | | 2.9.1, 2.10.1, 2.11.0 | smdistributed-dataparallel==v1.4.1 | | 2.8.3 | smdistributed-dataparallel==v1.3.0 | ## Regioni AWS La libreria SMDDP è disponibile in tutti i paesi in Regioni AWS cui sono in servizio le [immagini [AWS Deep Learning Containers for SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) e SMP Docker](distributed-model-parallel-support-v2.md). ## Tipi di istanze supportati La libreria SMDDP richiede uno dei seguenti tipi di istanza ML. | Tipo di istanza | | --- | | ml.p3dn.24xlarge\$1 | | ml.p4d.24xlarge | | ml.p4de.24xlarge | **Suggerimento** Per eseguire correttamente l’addestramento distribuito sui tipi di istanze abilitati per EFA, è necessario abilitare il traffico tra le istanze configurando il gruppo di sicurezza del VPC in cui sia consentito tutto il traffico in entrata e in uscita dal gruppo stesso. Per informazioni su come configurare le regole del gruppo di sicurezza, consulta [Fase 1: preparare un gruppo di sicurezza abilitato per EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) nella *Guida per l’utente di Amazon EC2*. **Importante** \$1 La libreria SMDDP ha interrotto il supporto per l’ottimizzazione delle operazioni di comunicazione collettiva sulle istanze P3. Sebbene sia comunque possibile utilizzare l’operazione collettiva `AllReduce` ottimizzata per SMDDP sulle istanze `ml.p3dn.24xlarge`, non è più disponibile alcun ulteriore supporto allo sviluppo per migliorare le prestazioni su questo tipo di istanza. Tieni presente che l’operazione collettiva `AllGather` ottimizzata per SMDDP è disponibile solo per le istanze P4. Per le specifiche dei tipi di istanza, consulta la sezione **Elaborazione accelerata** nella [pagina tipi di istanza Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Per informazioni sui prezzi delle istanze, consulta la pagina [ SageMaker Prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/). Se hai riscontrato un messaggio di errore simile al seguente, segui le istruzioni in [Richiedi un aumento della quota di servizio per le risorse di SageMaker intelligenza artificiale](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure). ``` ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling the CreateTrainingJob operation: The account-level service limit 'ml.p3dn.24xlarge for training job usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please contact AWS support to request an increase for this limit. ``` # Formazione distribuita con la libreria di parallelismo dei dati distribuiti SageMaker AI La libreria SageMaker AI Distributed Data Parallelism (SMDDP) è progettata per la facilità d'uso e per fornire una perfetta integrazione con. PyTorch Durante l'addestramento di un modello di deep learning con la libreria SMDDP sull' SageMaker intelligenza artificiale, puoi concentrarti sulla stesura dello script di addestramento e sulla formazione del modello. Per iniziare, importa la libreria SMDDP per utilizzarne le operazioni collettive ottimizzate per AWS. I seguenti argomenti forniscono istruzioni sugli elementi da aggiungere allo script di addestramento a seconda dell’operazione collettiva da ottimizzare. **Topics** + [Adattamento dello script di addestramento per l’utilizzo delle operazioni collettive SMDDP](data-parallel-modify-sdp-select-framework.md) + [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md) # Adattamento dello script di addestramento per l’utilizzo delle operazioni collettive SMDDP Gli esempi di script di addestramento forniti in questa sezione sono semplificati ed evidenziano solo le modifiche necessarie per abilitare la libreria SageMaker AI Distributed Data Parallelism (SMDDP) nello script di addestramento. Per esempi di notebook end-to-end Jupyter che dimostrano come eseguire un processo di formazione distribuito con la libreria SMDDP, vedere. [Esempi di librerie di parallelismo dei dati di Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) **Topics** + [Utilizzate la libreria SMDDP nello script di addestramento PyTorch](data-parallel-modify-sdp-pt.md) + [Usa la libreria SMDDP nello script di addestramento Lightning PyTorch](data-parallel-modify-sdp-pt-lightning.md) + [Usa la libreria SMDDP nello script di formazione (obsoleto) TensorFlow](data-parallel-modify-sdp-tf2.md) # Utilizzate la libreria SMDDP nello script di addestramento PyTorch [A partire dalla libreria SageMaker AI Distributed Data Parallelism (SMDDP) v1.4.0, puoi utilizzare la libreria come opzione di backend per il pacchetto distribuito. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) Per utilizzare SMDDP `AllReduce` e le operazioni `AllGather` collettive, è sufficiente importare la libreria SMDDP all'inizio dello script di formazione e impostare SMDDP come backend dei moduli distribuiti durante l'inizializzazione del gruppo di processi. PyTorch Con la singola riga di specifiche del backend, è possibile mantenere invariati tutti i moduli distribuiti nativi PyTorch e l'intero script di formazione. [I seguenti frammenti di codice mostrano come utilizzare la libreria SMDDP come backend di pacchetti di formazione distribuiti PyTorch basati: distributed [PyTorch data parallel (DDP), PyTorch Fully Sharded Data Parallelism (FSDP)](https://pytorch.org/docs/stable/notes/ddp.html)[e Megatron](https://pytorch.org/docs/stable/fsdp.html) -. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed) ## PyTorch Per DDP o FSDP Inizializza il gruppo di processi come segue. ``` import torch.distributed as dist import smdistributed.dataparallel.torch.torch_smddp dist.init_process_group(backend="smddp") ``` **Nota** (Solo per i lavori PyTorch DDP) Il `smddp` backend attualmente non supporta la creazione di gruppi di sottoprocessi con l'API. `torch.distributed.new_group()` Non è possibile utilizzare il backend `smddp` contemporaneamente ad altri back-end di gruppi di processi come `NCCL` e `Gloo`. ## Per DeepSpeed o Megatron- DeepSpeed Inizializza il gruppo di processi come segue. ``` import deepspeed import smdistributed.dataparallel.torch.torch_smddp deepspeed.init_distributed(dist_backend="smddp") ``` **Nota** Per utilizzare `AllGather` SMDDP con i programmi di avvio basati su `mpirun` (`smdistributed` e `pytorchddp`) in [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md), è inoltre necessario impostare la seguente variabile di ambiente nello script di addestramento. ``` export SMDATAPARALLEL_OPTIMIZE_SDP=true ``` Per indicazioni generali sulla scrittura di uno script di formazione PyTorch FSDP, consulta [Advanced Model Training with Fully Sharded Data Parallel (FSDP](https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html)) nella documentazione. PyTorch Per indicazioni generali sulla scrittura di uno script di addestramento PyTorch DDP, consulta [Getting started with distributed data parallel](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) nella PyTorch documentazione. Dopo aver completato l’adattamento dello script di addestramento, procedi con [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md). # Usa la libreria SMDDP nello script di addestramento Lightning PyTorch Se desideri utilizzare lo script di formazione [PyTorchLightning](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction.html) ed eseguire un processo di formazione parallela con dati distribuiti in SageMaker AI, puoi eseguire il processo di formazione con modifiche minime allo script di formazione. Le modifiche necessarie includono quanto segue: importazione dei PyTorch moduli della `smdistributed.dataparallel` libreria, impostazione delle variabili di ambiente per PyTorch Lightning in modo che accettino le variabili di ambiente SageMaker AI preimpostate dal toolkit di SageMaker formazione e attivazione della libreria SMDDP impostando il backend del gruppo di processi su. `"smddp"` Per ulteriori informazioni, segui le seguenti istruzioni che descrivono le fasi con esempi di codice. **Nota** Il supporto PyTorch Lightning è disponibile nella libreria parallela di dati SageMaker AI v1.5.0 e versioni successive. ## PyTorch Lightning == v2.1.0 e == 2.0.1 PyTorch 1. Importa la libreria `pytorch_lightning` e i moduli `smdistributed.dataparallel.torch`. ``` import lightning as pl import smdistributed.dataparallel.torch.torch_smddp ``` 1. [LightningEnvironment](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.plugins.environments.LightningEnvironment.html)Istanzia il. ``` from lightning.fabric.plugins.environments.lightning import LightningEnvironment env = LightningEnvironment() env.world_size = lambda: int(os.environ["WORLD_SIZE"]) env.global_rank = lambda: int(os.environ["RANK"]) ``` 1. **Per PyTorch DDP**[: crea un oggetto della [DDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.DDPStrategy.html)classe con `"smddp"` for `process_group_backend` e `"gpu"` for`accelerator`, e passalo alla classe Trainer.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html) ``` import lightning as pl from lightning.pytorch.strategies import DDPStrategy ddp = DDPStrategy( cluster_environment=env, process_group_backend="smddp", accelerator="gpu" ) trainer = pl.Trainer( max_epochs=200, strategy=ddp, devices=num_gpus, num_nodes=num_nodes ) ``` **Per PyTorch FSDP**[: crea un oggetto della [FSDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.FSDPStrategy.html)classe (con la [politica di wrapping](https://pytorch.org/docs/stable/fsdp.html) preferita) con `"smddp"` for `process_group_backend` e `"gpu"` for `accelerator` e passalo alla classe Trainer.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html) ``` import lightning as pl from lightning.pytorch.strategies import FSDPStrategy from functools import partial from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy policy = partial( size_based_auto_wrap_policy, min_num_params=10000 ) fsdp = FSDPStrategy( auto_wrap_policy=policy, process_group_backend="smddp", cluster_environment=env ) trainer = pl.Trainer( max_epochs=200, strategy=fsdp, devices=num_gpus, num_nodes=num_nodes ) ``` Dopo aver completato l’adattamento dello script di addestramento, procedi con [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md). **Nota** Quando costruisci uno strumento di PyTorch valutazione dell' SageMaker intelligenza artificiale e invii una richiesta di lavoro di formazione in[Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md), devi provvedere all'installazione `pytorch-lightning` e `lightning-bolts` all'inserimento nel contenitore di formazione `requirements.txt` AI. SageMaker PyTorch ``` # requirements.txt pytorch-lightning lightning-bolts ``` Per ulteriori informazioni su come specificare la directory di origine in cui inserire il `requirements.txt` file insieme allo script di formazione e all'invio di un lavoro, consulta la sezione [Utilizzo di librerie di terze parti nella documentazione](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) di *Amazon AI SageMaker Python SDK*. # Usa la libreria SMDDP nello script di formazione (obsoleto) TensorFlow **Importante** La libreria SMDDP ha interrotto il supporto TensorFlow e non è più disponibile nelle TensorFlow versioni successive alla DLCs v2.11.0. Per trovare le versioni precedenti TensorFlow DLCs con la libreria SMDDP installata, vedere. [Framework supportati](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks) I passaggi seguenti mostrano come modificare uno script di TensorFlow addestramento per utilizzare la libreria parallela di dati distribuiti di SageMaker AI.  La libreria APIs è progettata per essere simile a APIs Horovod. Per ulteriori dettagli su ciascuna API offerta dalla libreria TensorFlow, consulta la [documentazione dell' TensorFlow API SageMaker AI distributed data parallel](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation). **Nota** SageMaker L'AI distributed data parallel è adattabile agli script di TensorFlow addestramento composti da moduli `tf` principali ad eccezione `tf.keras` dei moduli. SageMaker L'AI distributed data parallel non supporta TensorFlow l'implementazione Keras. **Nota** La libreria di parallelismo dei dati distribuiti SageMaker AI supporta immediatamente Automatic Mixed Precision (AMP). Non è necessaria alcuna azione aggiuntiva per abilitare AMP oltre alle modifiche a livello di framework allo script di addestramento. Se i gradienti sono presenti FP16, la libreria di parallelismo dei dati SageMaker AI esegue il suo funzionamento in. `AllReduce` FP16 Per ulteriori informazioni sull'implementazione di AMP nello script APIs di formazione, consulta le seguenti risorse: [Frameworks: TensorFlow nella documentazione](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) di *NVIDIA Deep* Learning Performance [Automatic mixed precision for deep learning](https://developer.nvidia.com/automatic-mixed-precision) nella *documentazione per sviluppatori NVIDIA* [TensorFlow precisione APIs mista](https://www.tensorflow.org/guide/mixed_precision) *nella documentazione TensorFlow* 1. Importa il TensorFlow client della libreria e inizializzalo. ``` import smdistributed.dataparallel.tensorflow as sdp  sdp.init() ``` 1. Associa ogni GPU a un singolo processo `smdistributed.dataparallel` con `local_rank` —questo si riferisce al grado relativo del processo all'interno di un determinato nodo. L’API `sdp.tensorflow.local_rank()` fornisce la classificazione locale del dispositivo. Il nodo principale è di classificazione 0 e i nodi di lavoro sono di grado 1, 2, 3 e così via. Questo viene richiamato nel seguente blocco di codice come. `sdp.local_rank()` `set_memory_growth`non è direttamente correlato all' SageMaker intelligenza artificiale distribuita, ma deve essere impostato per l'addestramento distribuito con TensorFlow. ``` gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus:     tf.config.experimental.set_memory_growth(gpu, True) if gpus:     tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU') ``` 1. Scala il tasso di apprendimento in base al numero di worker. L'API `sdp.tensorflow.size()` fornisce il numero di worker nel cluster. Questo viene richiamato nel seguente blocco di codice come `sdp.size()`. ``` learning_rate = learning_rate * sdp.size() ``` 1. Utilizza le librerie `DistributedGradientTape` per ottimizzare le operazioni `AllReduce` durante l'addestramento. Questo esegue il wrapping di `tf.GradientTape`.  ``` with tf.GradientTape() as tape:       output = model(input)       loss_value = loss(label, output)      # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape tape = sdp.DistributedGradientTape(tape) ``` 1. Trasmetti le variabili iniziali del modello dal nodo leader (rango 0) a tutti i nodi di lavoro (dai ranghi da 1 a n). Ciò è necessario per garantire un'inizializzazione coerente tra tutte le classificazioni dei worker. Utilizza l'API `sdp.tensorflow.broadcast_variables` dopo l'inizializzazione delle variabili del modello e dell'ottimizzatore. Questo viene richiamato nel seguente blocco di codice come `sdp.broadcast_variables()`. ``` sdp.broadcast_variables(model.variables, root_rank=0) sdp.broadcast_variables(opt.variables(), root_rank=0) ``` 1. Infine, modifica dello script per salvare i checkpoint solo sul nodo principale. Il nodo principale ha un modello sincronizzato. Ciò evita inoltre che i nodi di lavoro sovrascrivano i checkpoint e possano danneggiarli. ``` if sdp.rank() == 0:     checkpoint.save(checkpoint_dir) ``` Di seguito è riportato un esempio di script di TensorFlow formazione per la formazione distribuita con la libreria. ``` import tensorflow as tf # SageMaker AI data parallel: Import the library TF API import smdistributed.dataparallel.tensorflow as sdp # SageMaker AI data parallel: Initialize the library sdp.init() gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus:     tf.config.experimental.set_memory_growth(gpu, True) if gpus:     # SageMaker AI data parallel: Pin GPUs to a single library process     tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU') # Prepare Dataset dataset = tf.data.Dataset.from_tensor_slices(...) # Define Model mnist_model = tf.keras.Sequential(...) loss = tf.losses.SparseCategoricalCrossentropy() # SageMaker AI data parallel: Scale Learning Rate # LR for 8 node run : 0.000125 # LR for single node run : 0.001 opt = tf.optimizers.Adam(0.000125 * sdp.size()) @tf.function def training_step(images, labels, first_batch):     with tf.GradientTape() as tape:         probs = mnist_model(images, training=True)         loss_value = loss(labels, probs)     # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape     tape = sdp.DistributedGradientTape(tape)     grads = tape.gradient(loss_value, mnist_model.trainable_variables)     opt.apply_gradients(zip(grads, mnist_model.trainable_variables))     if first_batch:        # SageMaker AI data parallel: Broadcast model and optimizer variables        sdp.broadcast_variables(mnist_model.variables, root_rank=0)        sdp.broadcast_variables(opt.variables(), root_rank=0)     return loss_value ... # SageMaker AI data parallel: Save checkpoints only from master node. if sdp.rank() == 0:     checkpoint.save(checkpoint_dir) ``` Dopo aver completato l'adattamento dello script di addestramento, passa a [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md). # Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker Per eseguire un processo di formazione distribuito con il tuo script adattato da[Adattamento dello script di addestramento per l’utilizzo delle operazioni collettive SMDDP](data-parallel-modify-sdp-select-framework.md), usa il framework di SageMaker Python SDK o gli stimatori generici specificando lo script di formazione preparato come script di ingresso e la configurazione di formazione distribuita. Questa pagina illustra come utilizzare [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) in due modi. + Se vuoi adottare rapidamente il tuo lavoro di formazione distribuito sull' SageMaker intelligenza artificiale, configura una classe di stima dell' SageMaker intelligenza artificiale [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)o del [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)framework. Il framework estimator preleva lo script di allenamento e abbina automaticamente l'URI dell'immagine corretta dei Deep Learning Containers (DLC) [predefiniti PyTorch o dei TensorFlow Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), dato il valore specificato nel parametro. `framework_version` + Se desideri estendere uno dei container predefiniti o creare un contenitore personalizzato per creare il tuo ambiente ML con SageMaker AI, usa la `Estimator` classe generica SageMaker AI e specifica l'URI dell'immagine del contenitore Docker personalizzato ospitato nel tuo Amazon Elastic Container Registry (Amazon ECR). I tuoi set di dati di formazione devono essere archiviati in Amazon S3 o [ FSx Amazon for](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Lustre nel luogo in cui stai avviando Regione AWS il tuo processo di formazione. Se utilizzi notebook Jupyter, dovresti avere un'istanza SageMaker notebook o un'app Studio Classic in esecuzione sullo stesso. SageMaker Regione AWS Per ulteriori informazioni sull'archiviazione dei dati di addestramento, consulta la documentazione sugli input di [dati dell'SDK di SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). **Suggerimento** Ti consigliamo di utilizzare Amazon FSx for Lustre anziché Amazon S3 per migliorare le prestazioni di formazione. Amazon FSx ha un throughput più elevato e una latenza inferiore rispetto ad Amazon S3. **Suggerimento** Per eseguire correttamente l’addestramento distribuito sui tipi di istanze abilitati per EFA, è necessario abilitare il traffico tra le istanze configurando il gruppo di sicurezza del VPC per consentire tutto il traffico in entrata e in uscita dal gruppo stesso. Per informazioni su come configurare le regole del gruppo di sicurezza, consulta [Fase 1: preparare un gruppo di sicurezza abilitato per EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) nella *Guida per l’utente di Amazon EC2*. Scegli uno degli argomenti seguenti per istruzioni su come eseguire un job di addestramento distribuito del tuo script di addestramento. Dopo aver avviato un processo di formazione, puoi monitorare l'utilizzo del sistema e modellare le prestazioni utilizzando Amazon [Amazon SageMaker Debugger](train-debugger.md) o Amazon CloudWatch. Oltre a seguire le istruzioni riportate nei seguenti argomenti per saperne di più sui dettagli tecnici, ti consigliamo anche di provare [Esempi di librerie di parallelismo dei dati di Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) per iniziare. **Topics** + [Usa gli stimatori del PyTorch framework nell'SDK SageMaker Python](data-parallel-framework-estimator.md) + [Usa lo stimatore generico SageMaker AI per estendere i contenitori DLC predefiniti](data-parallel-use-python-skd-api.md) + [Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI](data-parallel-bring-your-own-container.md) # Usa gli stimatori del PyTorch framework nell'SDK SageMaker Python Puoi avviare un corso di formazione distribuito aggiungendo l'`distribution`argomento agli estimatori del framework SageMaker AI oppure. [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch) Per maggiori dettagli, scegli uno dei framework supportati dalla libreria SageMaker AI distributed data parallelism (SMDDP) tra le seguenti selezioni. ------ #### [ PyTorch ] Le seguenti opzioni di avvio sono disponibili per avviare la formazione distribuita. PyTorch + `pytorchddp`— Questa opzione esegue `mpirun` e imposta le variabili di ambiente necessarie per eseguire la formazione PyTorch distribuita sull' SageMaker intelligenza artificiale. Per utilizzare questa opzione, passa il seguente dizionario al parametro `distribution`. ``` { "pytorchddp": { "enabled": True } } ``` + `torch_distributed`— Questa opzione esegue `torchrun` e imposta le variabili di ambiente necessarie per eseguire l'addestramento PyTorch distribuito sull' SageMaker intelligenza artificiale. Per utilizzare questa opzione, passa il seguente dizionario al parametro `distribution`. ``` { "torch_distributed": { "enabled": True } } ``` + `smdistributed`— Anche questa opzione funziona`mpirun`, ma insieme a `smddprun` ciò imposta le variabili di ambiente necessarie per eseguire la formazione PyTorch distribuita sull' SageMaker intelligenza artificiale. ``` { "smdistributed": { "dataparallel": { "enabled": True } } } ``` Se si sceglie di sostituire `AllGather` NCCL con `AllGather` SMDDP, è possibile utilizzare tutte le tre opzioni. Scegli un’opzione adatta al tuo caso d’uso. Se hai scelto di sostituire `AllReduce` NCCL con `AllReduce` SMDDP, devi scegliere una delle opzioni basate su `mpirun`: `smdistributed` o `pytorchddp`. Puoi anche aggiungere ulteriori opzioni MPI come segue. ``` { "pytorchddp": { "enabled": True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION" } } ``` ``` { "smdistributed": { "dataparallel": { "enabled": True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION" } } } ``` Il seguente esempio di codice mostra la struttura di base di uno PyTorch stimatore con opzioni di formazione distribuite. ``` from sagemaker.pytorch import PyTorch pt_estimator = PyTorch( base_job_name="training_job_name_prefix", source_dir="subdirectory-to-your-code", entry_point="adapted-training-script.py", role="SageMakerRole", py_version="py310", framework_version="2.0.1",     # For running a multi-node distributed training job, specify a value greater than 1     # Example: 2,3,4,..8 instance_count=2,     # Instance types supported by the SageMaker AI data parallel library: # ml.p4d.24xlarge, ml.p4de.24xlarge instance_type="ml.p4d.24xlarge", # Activate distributed training with SMDDP distribution={ "pytorchddp": { "enabled": True } } # mpirun, activates SMDDP AllReduce OR AllGather # distribution={ "torch_distributed": { "enabled": True } } # torchrun, activates SMDDP AllGather # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } # mpirun, activates SMDDP AllReduce OR AllGather ) pt_estimator.fit("s3://bucket/path/to/training/data") ``` **Nota** PyTorch Lightning e le sue librerie di utilità come Lightning Bolts non sono preinstallate nell'IA. SageMaker PyTorch DLCs Crea il seguente file `requirements.txt` e salvalo nella directory di origine in cui salvi lo script di addestramento. ``` # requirements.txt pytorch-lightning lightning-bolts ``` Ad esempio, la struttura di directory deve essere simile alla seguente: ``` ├── pytorch_training_launcher_jupyter_notebook.ipynb └── sub-folder-for-your-code ├── adapted-training-script.py └── requirements.txt ``` Per ulteriori informazioni su come specificare la directory di origine in cui inserire il `requirements.txt` file insieme allo script di formazione e all'invio di un lavoro, consulta la sezione [Utilizzo di librerie di terze parti nella documentazione](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) di *Amazon AI SageMaker Python SDK*. **Considerazioni sull’attivazione delle operazioni collettive SMDDP e sull’utilizzo delle opzioni idonee di avvio dell’addestramento distribuito** + `AllReduce` e `AllGather` SMDDP non sono attualmente compatibili tra loro. + `AllReduce` SMDDP è attivato per impostazione predefinita in caso di utilizzo di `smdistributed` o `pytorchddp`, ovvero programmi di avvio basati su `mpirun`, e viene utilizzata l’operazione `AllGather` NCCL. + L’operazione `AllGather` SMDDP è attivata per impostazione predefinita in caso di utilizzo del programma di avvio `torch_distributed` e `AllReduce` ricorre a NCCL. + È possibile attivare `AllGather` SMDDP anche in caso di utilizzo dei programmi di avvio basati su `mpirun` con una variabile di ambiente aggiuntiva impostata come segue. ``` export SMDATAPARALLEL_OPTIMIZE_SDP=true ``` ------ #### [ TensorFlow ] **Importante** La libreria SMDDP ha interrotto il supporto TensorFlow e non è più disponibile nelle versioni successive alla versione 2.11.0. DLCs TensorFlow Per trovare le versioni precedenti TensorFlow DLCs con la libreria SMDDP installata, vedere. [TensorFlow (obsoleto)](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks-tensorflow) ``` from sagemaker.tensorflow import TensorFlow tf_estimator = TensorFlow( base_job_name = "training_job_name_prefix", entry_point="adapted-training-script.py", role="SageMakerRole", framework_version="2.11.0", py_version="py38",     # For running a multi-node distributed training job, specify a value greater than 1 # Example: 2,3,4,..8 instance_count=2,     # Instance types supported by the SageMaker AI data parallel library: # ml.p4d.24xlarge, ml.p3dn.24xlarge, and ml.p3.16xlarge instance_type="ml.p3.16xlarge",     # Training using the SageMaker AI data parallel distributed training strategy distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } ) tf_estimator.fit("s3://bucket/path/to/training/data") ``` ------ # Usa lo stimatore generico SageMaker AI per estendere i contenitori DLC predefiniti Puoi personalizzare i contenitori SageMaker AI predefiniti o estenderli per gestire eventuali requisiti funzionali aggiuntivi per il tuo algoritmo o modello che l'immagine Docker SageMaker AI precostruita non supporta. Per un esempio di come è possibile estendere un container predefinito, consulta [Estendere un container predefinito](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html). Per estendere un container predefinito o adattare il tuo container all'uso della libreria, devi utilizzare una delle immagini elencate in [Framework supportati](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks). **Nota** A partire dalla TensorFlow versione 2.4.1 e PyTorch 1.8.1, il framework SageMaker DLCs AI supporta i tipi di istanze abilitati per EFA. Ti consigliamo di utilizzare le immagini DLC che contengono la TensorFlow versione 2.4.1 o successiva e la versione 1.8.1 o successiva. PyTorch Ad esempio, se lo utilizzi PyTorch, il tuo Dockerfile dovrebbe contenere un'`FROM`istruzione simile alla seguente: ``` # SageMaker AI PyTorch image FROM 763104351884.dkr.ecr..amazonaws.com/pytorch-training: ENV PATH="/opt/ml/code:${PATH}" # this environment variable is used by the SageMaker AI PyTorch container to determine our user code directory. ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code # /opt/ml and all subdirectories are utilized by SageMaker AI, use the /code subdirectory to store your user code. COPY train.py /opt/ml/code/train.py # Defines cifar10.py as script entrypoint ENV SAGEMAKER_PROGRAM train.py ``` Puoi personalizzare ulteriormente il tuo contenitore Docker per lavorare con l' SageMaker intelligenza artificiale utilizzando il [toolkit di SageMaker formazione](https://github.com/aws/sagemaker-training-toolkit) e il file binario della libreria parallela di SageMaker dati distribuiti AI. Per ulteriori informazioni, consulta le istruzioni nella sezione seguente. # Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI Per creare il tuo contenitore Docker per l'addestramento e utilizzare la libreria parallela di dati SageMaker AI, devi includere le dipendenze corrette e i file binari delle librerie parallele distribuite SageMaker AI nel tuo Dockerfile. Questa sezione fornisce istruzioni su come creare un Dockerfile completo con il set minimo di dipendenze per l'addestramento distribuito nell' SageMaker intelligenza artificiale utilizzando la libreria parallela di dati. **Nota** Questa opzione Docker personalizzata con la libreria parallela di dati SageMaker AI come binario è disponibile solo per PyTorch. **Per creare un Dockerfile con il toolkit di SageMaker formazione e la libreria data parallel** 1. Inizia con un'immagine Docker di [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Usa le versioni per sviluppatori cuDNN che contengono il runtime CUDA e gli strumenti di sviluppo (intestazioni e librerie) per creare dal codice sorgente. PyTorch ](https://github.com/pytorch/pytorch#from-source) ``` FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04 ``` **Suggerimento** [Le immagini ufficiali del AWS Deep Learning Container (DLC) sono create a partire dalle immagini di base di NVIDIA CUDA.](https://hub.docker.com/r/nvidia/cuda) Se desideri utilizzare le immagini DLC predefinite come riferimenti mentre segui il resto delle istruzioni, consulta [AWS Deep Learning Containers for PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch) Dockerfiles. 1. Aggiungi i seguenti argomenti per specificare le versioni e gli altri pacchetti. PyTorch Inoltre, indica i percorsi dei bucket Amazon S3 verso la libreria parallela di SageMaker dati AI e altri software per utilizzare AWS le risorse, come il plug-in Amazon S3. Per utilizzare versioni delle librerie di terze parti diverse da quelle fornite nel seguente esempio di codice, ti consigliamo di consultare i [Dockerfile ufficiali di AWS Deep Learning Container PyTorch per](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) trovare versioni testate, compatibili e adatte alla tua applicazione. URLs Per trovare l'`SMDATAPARALLEL_BINARY`argomento, consulta le tabelle di ricerca all'indirizzo. [Framework supportati](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks) ``` ARG PYTORCH_VERSION=1.10.2 ARG PYTHON_SHORT_VERSION=3.8 ARG EFA_VERSION=1.14.1 ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl ARG CONDA_PREFIX="/opt/conda" ARG BRANCH_OFI=1.1.3-aws ``` 1. Imposta le seguenti variabili di ambiente per creare correttamente i componenti di SageMaker addestramento ed eseguire la libreria parallela di dati. Queste variabili vengono utilizzate per i componenti nelle fasi successive. ``` # Set ENV variables required to build PyTorch ENV TORCH_CUDA_ARCH_LIST="7.0+PTX 8.0" ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all" ENV NCCL_VERSION=2.10.3 # Add OpenMPI to the path. ENV PATH /opt/amazon/openmpi/bin:$PATH # Add Conda to path ENV PATH $CONDA_PREFIX/bin:$PATH # Set this enviroment variable for SageMaker AI to launch SMDDP correctly. ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main # Add enviroment variable for processes to be able to call fork() ENV RDMAV_FORK_SAFE=1 # Indicate the container type ENV DLC_CONTAINER_TYPE=training # Add EFA and SMDDP to LD library path ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH" ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH ``` 1. Installa o aggiorna `curl`, `wget` e `git` per scaricare e creare pacchetti nelle fasi successive. ``` RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ curl \ wget \ git \ && rm -rf /var/lib/apt/lists/* ``` 1. Installa il software [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) per la comunicazione di rete Amazon EC2. ``` RUN DEBIAN_FRONTEND=noninteractive apt-get update RUN mkdir /tmp/efa \ && cd /tmp/efa \ && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \ && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \ && cd aws-efa-installer \ && ./efa_installer.sh -y --skip-kmod -g \ && rm -rf /tmp/efa ``` 1. Installa [Conda](https://docs.conda.io/en/latest/) per eseguire la gestione dei pacchetti. ``` RUN curl -fsSL -v -o ~/miniconda.sh -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \ chmod +x ~/miniconda.sh && \ ~/miniconda.sh -b -p $CONDA_PREFIX && \ rm ~/miniconda.sh && \ $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \ $CONDA_PREFIX/bin/conda clean -ya ``` 1. Ottieni, compila e installa PyTorch e le relative dipendenze. Creiamo [PyTorch a partire dal codice sorgente](https://github.com/pytorch/pytorch#from-source) perché dobbiamo avere il controllo della versione NCCL per garantire la compatibilità con il plug-in [AWS OFI](https://github.com/aws/aws-ofi-nccl) NCCL. 1. [Seguendo i passaggi del [dockerfile PyTorch ufficiale](https://github.com/pytorch/pytorch/blob/master/Dockerfile), installa build dependencies e configura ccache per velocizzare la ricompilazione.](https://ccache.dev/) ``` RUN DEBIAN_FRONTEND=noninteractive \ apt-get install -y --no-install-recommends \ build-essential \ ca-certificates \ ccache \ cmake \ git \ libjpeg-dev \ libpng-dev \ && rm -rf /var/lib/apt/lists/* # Setup ccache RUN /usr/sbin/update-ccache-symlinks RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache ``` 1. [Le dipendenze comuni di Install PyTorch e Linux.](https://github.com/pytorch/pytorch#install-dependencies) ``` # Common dependencies for PyTorch RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses # Linux specific dependency for PyTorch RUN conda install -c pytorch magma-cuda113 ``` 1. [Clona il PyTorch GitHub repository.](https://github.com/pytorch/pytorch) ``` RUN --mount=type=cache,target=/opt/ccache \ cd / \ && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION} ``` 1. Installa e crea una versione [NCCL](https://developer.nvidia.com/nccl) specifica. Per fare ciò, sostituisci il contenuto nella cartella NCCL predefinita (`/pytorch/third_party/nccl`) con la PyTorch versione NCCL specifica del repository NVIDIA. La versione NCCL è stata impostata nella fase 3 di questa guida. ``` RUN cd /pytorch/third_party/nccl \ && rm -rf nccl \ && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \ && cd nccl \ && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \ && make pkg.txz.build \ && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1 ``` 1. PyTorchCompila e installa. Questo processo dura in genere poco più di 1 ora. È costruito utilizzando la versione NCCL scaricata nella fase precedente. ``` RUN cd /pytorch \ && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \ python setup.py install \ && rm -rf /pytorch ``` 1. Crea e installa il plugin [AWS OFI NCCL](https://github.com/aws/aws-ofi-nccl). Ciò consente il supporto [libfabric](https://github.com/ofiwg/libfabric) per la libreria parallela di dati SageMaker AI. ``` RUN DEBIAN_FRONTEND=noninteractive apt-get update \ && apt-get install -y --no-install-recommends \ autoconf \ automake \ libtool RUN mkdir /tmp/efa-ofi-nccl \ && cd /tmp/efa-ofi-nccl \ && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \ && cd aws-ofi-nccl \ && ./autogen.sh \ && ./configure --with-libfabric=/opt/amazon/efa \ --with-mpi=/opt/amazon/openmpi \ --with-cuda=/usr/local/cuda \ --with-nccl=$CONDA_PREFIX \ && make \ && make install \ && rm -rf /tmp/efa-ofi-nccl ``` 1. Compila e installa [TorchVision](https://github.com/pytorch/vision.git). ``` RUN pip install --no-cache-dir -U \ packaging \ mpi4py==3.0.3 RUN cd /tmp \ && git clone https://github.com/pytorch/vision.git -b v0.9.1 \ && cd vision \ && BUILD_VERSION="0.9.1+cu111" python setup.py install \ && cd /tmp \ && rm -rf vision ``` 1. Installa e configura OpenSSH. OpenSSH è necessario per consentire a MPI di comunicare tra container. Consenti a OpenSSH di comunicare con i container senza chiedere conferma. ``` RUN apt-get update \ && apt-get install -y --allow-downgrades --allow-change-held-packages --no-install-recommends \ && apt-get install -y --no-install-recommends openssh-client openssh-server \ && mkdir -p /var/run/sshd \ && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \ && echo " StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \ && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \ && rm -rf /var/lib/apt/lists/* # Configure OpenSSH so that nodes can communicate with each other RUN mkdir -p /var/run/sshd && \ sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd RUN rm -rf /root/.ssh/ && \ mkdir -p /root/.ssh/ && \ ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \ cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \ && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config ``` 1. Installa il plug-in PT S3 per accedere in modo efficiente ai set di dati in Amazon S3. ``` RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU} RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt ``` 1. Installa la libreria [libboost](https://www.boost.org/). Questo pacchetto è necessario per collegare in rete la funzionalità IO asincrona della libreria parallela di SageMaker dati AI. ``` WORKDIR / RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \ && tar -xzf boost_1_73_0.tar.gz \ && cd boost_1_73_0 \ && ./bootstrap.sh \ && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \ && cd .. \ && rm -rf boost_1_73_0.tar.gz \ && rm -rf boost_1_73_0 \ && cd ${CONDA_PREFIX}/include/boost ``` 1. Installa i seguenti strumenti di SageMaker intelligenza artificiale per la formazione. PyTorch ``` WORKDIR /root RUN pip install --no-cache-dir -U \ smclarify \ "sagemaker>=2,<3" \ sagemaker-experiments==0.* \ sagemaker-pytorch-training ``` 1. Infine, installa il binario parallelo dei dati SageMaker AI e le dipendenze rimanenti. ``` RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ jq \ libhwloc-dev \ libnuma1 \ libnuma-dev \ libssl1.1 \ libtool \ hwloc \ && rm -rf /var/lib/apt/lists/* RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY} ``` 1. Dopo aver finito di creare il Dockerfile, consulta [Adapting Your Own Training Container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) per scoprire come creare il contenitore Docker, ospitarlo in Amazon ECR ed eseguire un processo di formazione utilizzando l'SDK Python. SageMaker Il codice di esempio seguente mostra un Dockerfile completo dopo aver combinato tutti i blocchi di codice precedenti. ``` # This file creates a docker image with minimum dependencies to run SageMaker AI data parallel training FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04 # Set appropiate versions and location for components ARG PYTORCH_VERSION=1.10.2 ARG PYTHON_SHORT_VERSION=3.8 ARG EFA_VERSION=1.14.1 ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl ARG CONDA_PREFIX="/opt/conda" ARG BRANCH_OFI=1.1.3-aws # Set ENV variables required to build PyTorch ENV TORCH_CUDA_ARCH_LIST="3.7 5.0 7.0+PTX 8.0" ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all" ENV NCCL_VERSION=2.10.3 # Add OpenMPI to the path. ENV PATH /opt/amazon/openmpi/bin:$PATH # Add Conda to path ENV PATH $CONDA_PREFIX/bin:$PATH # Set this enviroment variable for SageMaker AI to launch SMDDP correctly. ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main # Add enviroment variable for processes to be able to call fork() ENV RDMAV_FORK_SAFE=1 # Indicate the container type ENV DLC_CONTAINER_TYPE=training # Add EFA and SMDDP to LD library path ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH" ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH # Install basic dependencies to download and build other dependencies RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ curl \ wget \ git \ && rm -rf /var/lib/apt/lists/* # Install EFA. # This is required for SMDDP backend communication RUN DEBIAN_FRONTEND=noninteractive apt-get update RUN mkdir /tmp/efa \ && cd /tmp/efa \ && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \ && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \ && cd aws-efa-installer \ && ./efa_installer.sh -y --skip-kmod -g \ && rm -rf /tmp/efa # Install Conda RUN curl -fsSL -v -o ~/miniconda.sh -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \ chmod +x ~/miniconda.sh && \ ~/miniconda.sh -b -p $CONDA_PREFIX && \ rm ~/miniconda.sh && \ $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \ $CONDA_PREFIX/bin/conda clean -ya # Install PyTorch. # Start with dependencies listed in official PyTorch dockerfile # https://github.com/pytorch/pytorch/blob/master/Dockerfile RUN DEBIAN_FRONTEND=noninteractive \ apt-get install -y --no-install-recommends \ build-essential \ ca-certificates \ ccache \ cmake \ git \ libjpeg-dev \ libpng-dev && \ rm -rf /var/lib/apt/lists/* # Setup ccache RUN /usr/sbin/update-ccache-symlinks RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache # Common dependencies for PyTorch RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses # Linux specific dependency for PyTorch RUN conda install -c pytorch magma-cuda113 # Clone PyTorch RUN --mount=type=cache,target=/opt/ccache \ cd / \ && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION} # Note that we need to use the same NCCL version for PyTorch and OFI plugin. # To enforce that, install NCCL from source before building PT and OFI plugin. # Install NCCL. # Required for building OFI plugin (OFI requires NCCL's header files and library) RUN cd /pytorch/third_party/nccl \ && rm -rf nccl \ && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \ && cd nccl \ && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \ && make pkg.txz.build \ && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1 # Build and install PyTorch. RUN cd /pytorch \ && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \ python setup.py install \ && rm -rf /pytorch RUN ccache -C # Build and install OFI plugin. \ # It is required to use libfabric. RUN DEBIAN_FRONTEND=noninteractive apt-get update \ && apt-get install -y --no-install-recommends \ autoconf \ automake \ libtool RUN mkdir /tmp/efa-ofi-nccl \ && cd /tmp/efa-ofi-nccl \ && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \ && cd aws-ofi-nccl \ && ./autogen.sh \ && ./configure --with-libfabric=/opt/amazon/efa \ --with-mpi=/opt/amazon/openmpi \ --with-cuda=/usr/local/cuda \ --with-nccl=$CONDA_PREFIX \ && make \ && make install \ && rm -rf /tmp/efa-ofi-nccl # Build and install Torchvision RUN pip install --no-cache-dir -U \ packaging \ mpi4py==3.0.3 RUN cd /tmp \ && git clone https://github.com/pytorch/vision.git -b v0.9.1 \ && cd vision \ && BUILD_VERSION="0.9.1+cu111" python setup.py install \ && cd /tmp \ && rm -rf vision # Install OpenSSH. # Required for MPI to communicate between containers, allow OpenSSH to talk to containers without asking for confirmation RUN apt-get update \ && apt-get install -y --allow-downgrades --allow-change-held-packages --no-install-recommends \ && apt-get install -y --no-install-recommends openssh-client openssh-server \ && mkdir -p /var/run/sshd \ && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \ && echo " StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \ && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \ && rm -rf /var/lib/apt/lists/* # Configure OpenSSH so that nodes can communicate with each other RUN mkdir -p /var/run/sshd && \ sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd RUN rm -rf /root/.ssh/ && \ mkdir -p /root/.ssh/ && \ ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \ cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \ && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config # Install PT S3 plugin. # Required to efficiently access datasets in Amazon S3 RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU} RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt # Install libboost from source. # This package is needed for smdataparallel functionality (for networking asynchronous IO). WORKDIR / RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \ && tar -xzf boost_1_73_0.tar.gz \ && cd boost_1_73_0 \ && ./bootstrap.sh \ && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \ && cd .. \ && rm -rf boost_1_73_0.tar.gz \ && rm -rf boost_1_73_0 \ && cd ${CONDA_PREFIX}/include/boost # Install SageMaker AI PyTorch training. WORKDIR /root RUN pip install --no-cache-dir -U \ smclarify \ "sagemaker>=2,<3" \ sagemaker-experiments==0.* \ sagemaker-pytorch-training # Install SageMaker AI data parallel binary (SMDDP) # Start with dependencies RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ jq \ libhwloc-dev \ libnuma1 \ libnuma-dev \ libssl1.1 \ libtool \ hwloc \ && rm -rf /var/lib/apt/lists/* # Install SMDDP RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY} ``` **Suggerimento** [Per informazioni più generali sulla creazione di un Dockerfile personalizzato per la formazione nell'intelligenza artificiale, consulta Use Your Own Training Algorithms SageMaker .](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html) **Suggerimento** Se desideri estendere il Dockerfile personalizzato per incorporare la libreria parallela del SageMaker modello AI, consulta. [Crea il tuo contenitore Docker con la Distributed Model Parallel Library SageMaker](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container) # Esempi di librerie di parallelismo dei dati di Amazon SageMaker AI Questa pagina fornisce notebook Jupyter che presentano esempi di implementazione della libreria SageMaker AI Distributed Data Parallelism (SMDDP) per eseguire lavori di formazione distribuiti sull'IA. SageMaker ## Blog e casi di studio I seguenti blog illustrano casi di studio sull’utilizzo della libreria SMDDP. **Blog SMDDP v2** + [Abilita una formazione più rapida con la libreria parallela di dati Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/enable-faster-training-with-amazon-sagemaker-data-parallel-library/), *AWS Machine Learning Blog* (05 dicembre 2023) **Blog SMDDP v1** + [Come ho addestrato 10 TB per la diffusione stabile su SageMaker AI](https://medium.com/@emilywebber/how-i-trained-10tb-for-stable-diffusion-on-sagemaker-39dcea49ce32) in *Medium* (29 novembre 2022) + [Esegui PyTorch Lightning e PyTorch DDP nativo su Amazon SageMaker Training, con Amazon Search](https://aws.amazon.com/blogs/machine-learning/run-pytorch-lightning-and-native-pytorch-ddp-on-amazon-sagemaker-training-featuring-amazon-search/), *AWS Machine Learning Blog* (18 agosto 2022) + [Formazione YOLOv5 su AWS with PyTorch and the SageMaker AI distributed data parallel library](https://medium.com/@sitecao/training-yolov5-on-aws-with-pytorch-and-sagemaker-distributed-data-parallel-library-a196ab01409b), *Medium* (6 maggio 2022) + [Accelera l'addestramento dei EfficientNet modelli sull' SageMaker intelligenza SageMaker artificiale con PyTorch la libreria parallela di dati distribuiti AI](https://medium.com/@dangmz/speed-up-efficientnet-model-training-on-amazon-sagemaker-with-pytorch-and-sagemaker-distributed-dae4b048c01a), *Medium* (21 marzo 2022) + [Accelera la EfficientNet formazione AWS con la libreria parallela di dati distribuiti di SageMaker intelligenza artificiale](https://towardsdatascience.com/speed-up-efficientnet-training-on-aws-by-up-to-30-with-sagemaker-distributed-data-parallel-library-2dbf6d1e18e8), *Towards Data Science* (12 gennaio 2022) + [Hyundai riduce i tempi di formazione sui modelli di machine learning per i modelli di guida autonoma utilizzando Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/hyundai-reduces-training-time-for-autonomous-driving-models-using-amazon-sagemaker/), *AWS Machine Learning Blog* (25 giugno 2021) + [Formazione distribuita: addestrare BART/T5 per il riepilogo utilizzando Transformers e Amazon AI, SageMaker il](https://huggingface.co/blog/sagemaker-distributed-training-seq2seq) *sito Web di Hugging Face (8 aprile 2021)* ## Notebook di esempio [I taccuini di esempio sono disponibili nell'archivio degli esempi di AI. SageMaker GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/training/distributed_training/) Per scaricare gli esempi, esegui il comando seguente per clonare il repository e accedere a `training/distributed_training/pytorch/data_parallel`. **Nota** Clona ed esegui i taccuini di esempio nel seguente AI ML. SageMaker IDEs [SageMaker AI JupyterLab](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-jl.html) (disponibile in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creato dopo dicembre 2023) [SageMaker AI Code Editor](https://docs.aws.amazon.com/sagemaker/latest/dg/code-editor.html) (disponibile in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creato dopo dicembre 2023) [Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) (disponibile come applicazione in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creata dopo dicembre 2023) [SageMaker Istanze Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) ``` git clone https://github.com/aws/amazon-sagemaker-examples.git cd amazon-sagemaker-examples/training/distributed_training/pytorch/data_parallel ``` **Esempi SMDDP v2** + [Addestra Llama 2 utilizzando la libreria parallela di dati distribuita SageMaker AI (SMDDP) e DeepSpeed](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/deepspeed/llama2/smddp_deepspeed_example.ipynb) + [Addestra Falcon utilizzando la libreria parallela di dati distribuita SageMaker AI (SMDDP) e il PyTorch Fully Sharded Data Parallelism (FSDP)](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/fully_sharded_data_parallel/falcon/smddp_fsdp_example.ipynb) **Esempi SMDDP v1** + [CNN con e la libreria di parallelismo dei dati AI PyTorch SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/mnist/pytorch_smdataparallel_mnist_demo.ipynb) + [BERT with PyTorch e la libreria di parallelismo dei SageMaker dati AI](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/bert/pytorch_smdataparallel_bert_demo.ipynb) + [CNN con TensorFlow 2.3.1 e la libreria di parallelismo dei SageMaker dati AI](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/data_parallel/mnist/tensorflow2_smdataparallel_mnist_demo.html) + [BERT con TensorFlow 2.3.1 e la libreria di parallelismo dei dati AI SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/data_parallel/bert/tensorflow2_smdataparallel_bert_demo.html) + [HuggingFace Formazione parallela sui dati distribuiti PyTorch sull' SageMaker intelligenza artificiale - Risposta distribuita alle domande](https://github.com/huggingface/notebooks/blob/master/sagemaker/03_distributed_training_data_parallelism/sagemaker-notebook.ipynb) + [HuggingFace Formazione parallela sui dati distribuiti PyTorch sull' SageMaker intelligenza artificiale - Riepilogo del testo distribuito](https://github.com/huggingface/notebooks/blob/master/sagemaker/08_distributed_summarization_bart_t5/sagemaker-notebook.ipynb) + [HuggingFace Formazione parallela sui dati distribuiti TensorFlow sull'intelligenza artificiale SageMaker ](https://github.com/huggingface/notebooks/blob/master/sagemaker/07_tensorflow_distributed_training_data_parallelism/sagemaker-notebook.ipynb) # Suggerimenti di configurazione per la libreria di parallelismo dei dati distribuiti SageMaker AI Consulta i seguenti suggerimenti prima di utilizzare la libreria SageMaker AI Distributed Data Parallelism (SMDDP). Questo elenco include suggerimenti applicabili a tutti i framework. **Topics** + [Pre-elaborazione dei dati](#data-parallel-config-dataprep) + [Nodi singoli o multipli](#data-parallel-config-multi-node) + [Eseguire il debug dell’efficienza di dimensionamento con Debugger](#data-parallel-config-debug) + [Dimensione batch](#data-parallel-config-batch-size) + [Opzioni MPI personalizzate](#data-parallel-config-mpi-custom) + [Usa Amazon FSx e configura una capacità di storage e throughput ottimali](#data-parallel-config-fxs) ## Pre-elaborazione dei dati Se preelabori i dati durante l'allenamento utilizzando una libreria esterna che utilizza la CPU, potresti incorrere in un collo di bottiglia della CPU perché AI SageMaker distributed data parallel utilizza la CPU per le operazioni. `AllReduce` Potresti essere in grado di migliorare i tempi di allenamento spostando le fasi di preelaborazione in una libreria che utilizza GPUs o completando tutta la preelaborazione prima dell'allenamento. ## Nodi singoli o multipli È consigliabile utilizzare questa libreria con più nodi. La libreria può essere utilizzata con una configurazione a host singolo e multidispositivo (ad esempio, una singola istanza di calcolo ML con più nodi GPUs); tuttavia, quando si utilizzano due o più nodi, il `AllReduce` funzionamento della libreria offre un miglioramento significativo delle prestazioni. Inoltre, su un singolo host, contribuisce NVLink già all'efficienza dei nodi. `AllReduce` ## Eseguire il debug dell’efficienza di dimensionamento con Debugger Puoi usare Amazon SageMaker Debugger per monitorare e visualizzare l'utilizzo di CPU e GPU e altre metriche di interesse durante l'allenamento. Puoi utilizzare le [regole integrate](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html) di Debugger per monitorare i problemi di prestazioni computazionali, ad esempio, `CPUBottleneck`, `LoadBalancing` e `LowGPUUtilization`. Puoi specificare queste regole con le [configurazioni Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configuration-for-debugging.html) quando definisci uno stimatore SDK Amazon Python SageMaker . Se utilizzi AWS CLI e AWS SDK per Python (Boto3) per la formazione sull' SageMaker intelligenza artificiale, puoi abilitare Debugger come mostrato in [Configurare il debugger utilizzando l'API SageMaker Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html). SageMaker [Per vedere un esempio di utilizzo di Debugger in un lavoro di SageMaker formazione, puoi fare riferimento a uno degli esempi di notebook nel repository Notebook Examples. SageMaker GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger) [Per ulteriori informazioni su Debugger, consulta Amazon Debugger. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/train-debugger.html) ## Dimensione batch Nell’addestramento distribuito, man mano che vengono aggiunti più nodi, le dimensioni dei batch dovrebbero aumentare proporzionalmente. Per migliorare la velocità di convergenza man mano che aggiungi più nodi al tuo processo di addestramento e aumenti la dimensione globale del batch, aumenta il tasso di apprendimento. Un modo per raggiungere questo obiettivo è utilizzare un riscaldamento graduale del tasso di apprendimento, in cui il tasso di apprendimento passa da un valore piccolo a uno più grande man mano che il processo di addestramento progredisce. Questo incremento evita un aumento improvviso del tasso di apprendimento e consente una sana convergenza all'inizio dell’addestramento. Ad esempio, è possibile utilizzare una *Regola di dimensionamento lineare* in base alla quale ogni volta che la dimensione del mini-batch viene moltiplicata per k, anche il tasso di apprendimento viene moltiplicato per k. Per saperne di più su questa tecnica, consulta il paper di ricerca [Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour](https://arxiv.org/pdf/1706.02677.pdf), Sezioni 2 e 3. ## Opzioni MPI personalizzate La libreria parallela di dati distribuiti SageMaker AI utilizza Message Passing Interface (MPI), uno standard popolare per la gestione della comunicazione tra i nodi in un cluster ad alte prestazioni, e utilizza la libreria NCCL di NVIDIA per la comunicazione a livello di GPU. Quando si utilizza la libreria parallela di dati con un TensorFlow o Pytorch`Estimator`, il rispettivo contenitore configura l'ambiente MPI ed esegue il `mpirun` comando per avviare i lavori sui nodi del cluster. È possibile impostare operazioni MPI personalizzate utilizzando il parametro `custom_mpi_options` in `Estimator`. Tutti `mpirun` i flag passati in questo campo vengono aggiunti al `mpirun` comando ed eseguiti dall'IA per l'addestramento. SageMaker Ad esempio, è possibile definire il parametro `distribution` di un `Estimator` utilizzando quanto segue per utilizzare la variabile [https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-debug](https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-debug) per stampare la versione NCCL all'inizio del programma: ``` distribution = {'smdistributed':{'dataparallel':{'enabled': True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"}}} ``` ## Usa Amazon FSx e configura una capacità di storage e throughput ottimali [Quando si addestra un modello su più nodi con parallelismo distribuito dei dati, si consiglia vivamente di FSx utilizzarlo per Lustre.](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Amazon FSx è un servizio di storage scalabile e ad alte prestazioni che supporta lo storage di file condiviso con un throughput più veloce. Utilizzando FSx lo storage Amazon su larga scala, puoi ottenere una maggiore velocità di caricamento dei dati tra i nodi di elaborazione. In genere, con il parallelismo distribuito dei dati, ci si aspetterebbe che il throughput di formazione totale cresca quasi linearmente con il numero di. GPUs Tuttavia, se utilizzi uno FSx storage Amazon non ottimale, le prestazioni di formazione potrebbero rallentare a causa di un basso FSx throughput Amazon. Ad esempio, se utilizzi il tipo di [distribuzione **SCRATCH\$12** del FSx file system Amazon](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) con una capacità di storage minima di 1,2 TiB, la I/O capacità di throughput è 240. MB/s. Amazon FSx storage works in a way that you can assign physical storage devices, and the more devices assigned, the larger throughput you get. The smallest storage increment for the SRATCH\$12 type is 1.2 TiB, and the corresponding throughput gain is 240 MB/s Supponiamo di avere un modello da addestrare su un cluster a 4 nodi su un set di dati da 100 GB. Con una determinata dimensione del batch ottimizzata per il cluster, supponiamo che il modello possa completare un'epoca in circa 30 secondi. In questo caso, la I/O velocità minima richiesta è di circa 3 GB/s (100 GB/30 s). Apparentemente si tratta di un requisito di throughput molto più elevato rispetto a 240 problemi di MB/s. With such a limited Amazon FSx capacity, scaling your distributed training job up to larger clusters might aggravate I/O collo di bottiglia; il throughput di formazione del modello potrebbe migliorare in epoche successive con l'accumulo di cache, ma il throughput di Amazon FSx può ancora essere un collo di bottiglia. Per alleviare questi problemi di I/O collo di bottiglia, è necessario aumentare le dimensioni di FSx storage di Amazon per ottenere una maggiore capacità di throughput. In genere, per trovare un I/O throughput ottimale, puoi sperimentare diverse capacità di Amazon, assegnando un FSx throughput uguale o leggermente inferiore a quello stimato, finché non trovi che sia sufficiente a risolvere i problemi di collo di bottiglia. I/O Nel caso dell'esempio precedente, sarebbe sufficiente FSx lo storage Amazon con GB/s throughput 2,4 e cache RAM da 67 GB. Se il file system ha un throughput ottimale, il throughput di addestramento del modello dovrebbe raggiungere il massimo immediatamente o dopo la prima fase di accumulo della cache. Per ulteriori informazioni su come aumentare i tipi di FSx storage e distribuzione di Amazon, consulta le seguenti pagine nella *documentazione di Amazon FSx for Lustre*: + [Come aumentare la capacità di storage](https://docs.aws.amazon.com/fsx/latest/LustreGuide/managing-storage-capacity.html#increase-storage-capacity) + [Prestazioni aggregate del file system](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) # Domande frequenti sulla libreria Amazon SageMaker AI Distributed Data Parallelism Utilizza il seguente contenuto per trovare le risposte alle domande più frequenti sulla libreria SMDDP. **D: Quando si utilizza la libreria, come vengono gestite le istanze CPU che supportano `allreduce`? Devo creare cluster CPU-GPU eterogenei o il servizio SageMaker AI crea C5 aggiuntivi per i processi che utilizzano la libreria SMDDP?** La libreria SMDDP supporta solo le istanze della GPU, in particolare le istanze P4d e P4de con GPU NVIDIA A100 ed EFA. Non viene avviata alcuna istanza C5 o CPU aggiuntiva; se il job di addestramento di SageMaker AI riguarda un cluster P4d a 8 nodi, vengono utilizzate solo 8 istanze `ml.p4d.24xlarge`. Non viene fornita alcuna istanza aggiuntiva. **D: Ho un processo di addestramento che richiede 5 giorni su una singola istanza `ml.p3.24xlarge` con una serie di iperparametri H1 (tasso di apprendimento, dimensione del batch, ottimizzatore, ecc.). L’utilizzo della libreria SageMaker AI Distributed Data Parallelism e di un cluster cinque volte più grande è sufficiente per raggiungere una velocità di circa cinque volte maggiore? Oppure devo riesaminare i relativi iperparametri di addestramento dopo aver attivato la libreria SMDDP? ** La libreria modifica la dimensione complessiva del batch. La nuova dimensione complessiva del batch viene ridimensionata linearmente in base al numero di istanze di addestramento utilizzate. Di conseguenza, gli iperparametri, come il tasso di apprendimento, devono essere modificati per garantire la convergenza. **D: La libreria SMDDP supporta Spot? ** Sì. Puoi utilizzare Managed Spot Training. Devi specificare il percorso del file di checkpoint nel processo di addestramento SageMaker. I checkpoint vengono salvati e ripristinati nel relativo script di addestramento, come indicato nelle ultime fasi di [Usa la libreria SMDDP nello script di formazione (obsoleto) TensorFlow](data-parallel-modify-sdp-tf2.md) e [Utilizzate la libreria SMDDP nello script di addestramento PyTorch](data-parallel-modify-sdp-pt.md). **D: La libreria SMDDP è importante in una configurazione a host singolo e multidispositivo?** La libreria può essere utilizzata per l’addestramento su più dispositivi con host singolo, ma offre miglioramenti delle prestazioni solo nell’addestramento su più host. **D: Dove deve essere archiviato il set di dati di addestramento?** Il set di dati di addestramento può essere archiviato in un bucket Amazon S3 o su un'unità Amazon FSx. Consulta questo [documento per conoscere i vari file system di input supportati per un processo di addestramento](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html#sagemaker.inputs.FileSystemInput). **D: Quando si utilizza la libreria SMDDP, è obbligatorio disporre dei dati di addestramento in FSx per Lustre? È possibile utilizzare Amazon EFS e Amazon S3?** In genere consigliamo di utilizzare Amazon FSx a causa della sua latenza inferiore e della velocità di trasmissione effettiva maggiore. Se si preferisce, è possibile utilizzare Amazon EFS o Amazon S3. **D: La libreria può essere utilizzata con nodi CPU?** No. Per trovare i tipi di istanza supportati dalla libreria SMDDP, consulta [Tipi di istanze supportati](distributed-data-parallel-support.md#distributed-data-parallel-supported-instance-types). **D: Quali framework e versioni di framework sono attualmente supportati dalla libreria SMDDP al momento dell’avvio?** La libreria SMDDP attualmente supporta PyTorch v1.6.0 o versioni successive e TensorFlow v2.3.0 o versioni successive. Non supporta TensorFlow 1.x. Per ulteriori informazioni su quale versione della libreria SMDDP è inclusa nei Container AWS per il Deep Learning, consulta le [note di rilascio per i Container per il Deep learning](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/dlc-release-notes.html). **D: La libreria supporta AMP?** Sì. La libreria SMDDP supporta Automatic Mixed Precision (AMP) per impostazione predefinita. Non è necessaria alcuna azione aggiuntiva per usare l'AMP oltre alle modifiche a livello di framework allo script di addestramento. Se i gradienti sono in FP16, la libreria SageMaker AI Distributed Data Parallelism esegue l’operazione `AllReduce` in FP16. Per ulteriori informazioni sull'implementazione delle API AMP nello script di addestramento, consulta le seguenti risorse: + [Framework - PyTorch](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#pytorch) nella *documentazione NVIDIA Deep Learning Performance* + [Framework - TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) nella *documentazione NVIDIA Deep Learning Performance* + [Precisione mista automatica per il deep learning](https://developer.nvidia.com/automatic-mixed-precision) nella *documentazione per sviluppatori NVIDIA* + [Introducing native PyTorch automatic mixed precision for faster training on NVIDIA GPUs](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/) nel *Blog PyTorch* + [TensorFlow mixed precision APIs](https://www.tensorflow.org/guide/mixed_precision) nella *Documentazione di TensorFlow* **D: Come posso stabilire se il mio processo di addestramento distribuito è rallentato a causa di un collo di bottiglia di I/O?** Con un cluster più grande, il processo di addestramento richiede una maggiore velocità di I/O e pertanto la velocità di addestramento potrebbe impiegare più tempo (più epoche) per raggiungere le massime prestazioni. Ciò indica che l'I/O è bloccato e che la cache è più difficile da sviluppare man mano che si scalano i nodi (requisiti di velocità di trasmissione effettiva maggiore e topologia di rete più complessa). Per ulteriori informazioni sul monitoraggio del throughput di Amazon FSx su CloudWatch, consulta [Monitoraggio di FSx for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/monitoring_overview.html) nella *Guida per l’utente di FSx for Lustre*. **D: Come posso risolvere i problemi di I/O durante l'esecuzione di un processo di addestramento distribuito con parallelismo dei dati?** Ti consigliamo vivamente di utilizzare Amazon FSx come canale dati se utilizzi Amazon S3. Se utilizzi già Amazon FSx ma hai ancora problemi di collo di bottiglia di I/O, potresti aver configurato il tuo file system Amazon FSx con un throughput di I/O basso e una capacità di storage ridotta. Per ulteriori informazioni su come stimare e scegliere la giusta dimensione della capacità di throughput di I/O, consulta [Usa Amazon FSx e configura una capacità di storage e throughput ottimali](data-parallel-config.md#data-parallel-config-fxs). **D: (Per la libreria v1.4.0 o successiva) Come posso risolvere l'errore `Invalid backend` durante l'inizializzazione del gruppo di processi.** Se viene visualizzato il messaggio di errore `ValueError: Invalid backend: 'smddp'` durante la chiamata a `init_process_group`, ciò è dovuto alla modifica sostanziale nella libreria SMDDP v1.4.0 e versioni successive. È necessario importare il client PyTorch della libreria `smdistributed.dataparallel.torch.torch_smddp`, che registra `smddp` come back-end per PyTorch. Per ulteriori informazioni, consulta [Utilizzate la libreria SMDDP nello script di addestramento PyTorch](data-parallel-modify-sdp-pt.md). **D: (Per la libreria SMDDP v1.4.0 o versione successiva) Vorrei chiamare le primitive collettive dell’interfaccia [https://pytorch.org/docs/stable/distributed.html](https://pytorch.org/docs/stable/distributed.html). Quali primitive supporta il backend `smddp`?** Nella versione 1.4.0, la libreria SMDDP supporta `all_reduce`, `broadcast`, `reduce`, `all_gather` e `barrier` dell’interfaccia `torch.distributed`. **D: (Per la libreria SMDDP v1.4.0 o versione successiva) Questa nuova API funziona con altre classi o librerie DDP personalizzate, come Apex DDP? ** La libreria parallela SMDDP è testata con altre librerie Distributed Data Parallel di terze parti e implementazioni di framework che utilizzano i moduli `torch.distribtued`. L’utilizzo della libreria SMDDP con classi DDP personalizzate funziona purché le operazioni collettive utilizzate dalle classi DDP personalizzate siano supportate dalla libreria SMDDP. Vedi la domanda precedente per un elenco dei collettivi supportati. Se hai questi casi d’uso e hai bisogno di ulteriore supporto, contatta il team di SageMaker AI tramite il [Centro di supporto AWS](https://console.aws.amazon.com/support/) o [AWS Developer Forums for Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285). **D: La libreria SMDDP supporta l’opzione Bring Your Own Container (BYOC)? In tal caso, come posso installare la libreria ed eseguire un processo di addestramento distribuito scrivendo un Dockerfile personalizzato?** Se desideri integrare la libreria SMDDP e le sue dipendenze minime nel tuo container Docker, BYOC è l’approccio giusto. Puoi creare il tuo container utilizzando il file binario della libreria. Il processo consigliato consiste nello scrivere un Dockerfile personalizzato con la libreria e le sue dipendenze, creare il container Docker, ospitarlo in Amazon ECR e utilizzare l’URI dell’immagine ECR per avviare un job di addestramento utilizzando la classe dello strumento di stima generico di SageMaker AI. Per ulteriori istruzioni su come preparare un Dockerfile personalizzato per l’addestramento distribuito in SageMaker AI con la libreria SMDDP, consulta [Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI](data-parallel-bring-your-own-container.md). # Risoluzione dei problemi relativi alla formazione distribuita in Amazon SageMaker AI Se hai problemi nell'esecuzione di un processo di addestramento quando usi la libreria, usa il seguente elenco per provare a risolvere il problema. Se hai bisogno di ulteriore assistenza, contatta il team di SageMaker intelligenza artificiale tramite [AWS Support Center](https://console.aws.amazon.com/support/) o [AWS Developer Forums for Amazon Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285). **Topics** + [Utilizzo di dati distribuiti SageMaker AI in parallelo con Amazon SageMaker Debugger e checkpoint](#distributed-ts-data-parallel-debugger) + [Prefisso inaspettato collegato alle chiavi dei parametri del modello](#distributed-ts-data-parallel-pytorch-prefix) + [SageMaker Il processo di formazione distribuito dall'IA si blocca durante l'inizializzazione](#distributed-ts-data-parallel-efa-sg) + [SageMaker L'IA distribuiva il lavoro di formazione si interrompe alla fine della formazione](#distributed-ts-data-parallel-stall-at-the-end) + [Osservazione del degrado dell'efficienza di scalabilità dovuto alle difficoltà di throughput di Amazon FSx](#distributed-ts-data-parallel-fxs-bottleneck) + [SageMaker Lavoro di formazione distribuito basato sull'intelligenza artificiale con PyTorch restituisce avvisi di obsolescenza](#distributed-ts-data-parallel-deprecation-warnings) ## Utilizzo di dati distribuiti SageMaker AI in parallelo con Amazon SageMaker Debugger e checkpoint Per monitorare i colli di bottiglia del sistema, le operazioni del framework dei profili ed eseguire il debug dei tensori di output del modello per lavori di formazione con dati SageMaker distribuiti in parallelo all'intelligenza artificiale, usa Amazon Debugger. SageMaker Tuttavia, quando utilizzi SageMaker Debugger, SageMaker AI distributed data parallel e SageMaker AI checkpoint, potresti visualizzare un errore simile al seguente esempio. ``` SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled ``` Ciò è dovuto a un errore interno tra Debugger e checkpoint, che si verifica quando si SageMaker abilita AI distributed data parallel. + Se abiliti tutte e tre le funzionalità, SageMaker Python SDK disattiva automaticamente Debugger passando`debugger_hook_config=False`, il che equivale al seguente esempio di framework. `estimator` ``` bucket=sagemaker.Session().default_bucket() base_job_name="sagemaker-checkpoint-test" checkpoint_in_bucket="checkpoints" # The S3 URI to store the checkpoints checkpoint_s3_bucket="s3://{}/{}/{}".format(bucket, base_job_name, checkpoint_in_bucket) estimator = TensorFlow( ... distribution={"smdistributed": {"dataparallel": { "enabled": True }}}, checkpoint_s3_uri=checkpoint_s3_bucket, checkpoint_local_path="/opt/ml/checkpoints", debugger_hook_config=False ) ``` + Se desideri continuare a utilizzare sia SageMaker AI distributed data parallel che SageMaker Debugger, una soluzione alternativa consiste nell'aggiungere manualmente le funzioni di checkpointing allo script di addestramento invece di specificare i parametri e dallo stimatore. `checkpoint_s3_uri` `checkpoint_local_path` Per ulteriori informazioni sui checkpoint manuali in uno script di addestramento, consulta [Salvataggio dei checkpoint](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints). ## Prefisso inaspettato collegato alle chiavi dei parametri del modello Per i lavori di formazione PyTorch distribuiti, è possibile aggiungere un prefisso inaspettato (ad `model` esempio) alle chiavi (parametri del modello). `state_dict` La libreria parallela di dati SageMaker AI non altera o precede direttamente i nomi dei parametri del modello quando i lavori di PyTorch addestramento salvano gli artefatti del modello. L' PyTorchaddestramento distribuito modifica i nomi in modo che vengano trasmessi `state_dict` alla rete, anteponendo il prefisso. Se riscontri problemi di errore del modello a causa di nomi di parametri diversi mentre utilizzi la libreria parallela di dati SageMaker AI e il checkpointing per l' PyTorch addestramento, adatta il seguente codice di esempio per rimuovere il prefisso nella fase in cui carichi i checkpoint nello script di addestramento. ``` state_dict = {k.partition('model.')[2]:state_dict[k] for k in state_dict.keys()} ``` Questo prende ogni chiave `state_dict` come valore di stringa, separa la stringa alla prima occorrenza di `'model.'` e prende il terzo elemento dell'elenco (con indice 2) della stringa partizionata. Per ulteriori informazioni sul problema del prefisso, consultate il thread di discussione in [Prefix parameters names in saved model if training by multi-GPU](https://discuss.pytorch.org/t/prefix-parameter-names-in-saved-model-if-trained-by-multi-gpu/494)? *nel forum di discussione. PyTorch * Per ulteriori informazioni sui PyTorch metodi di salvataggio e caricamento dei modelli, vedere [Saving & Loading Model Across Devices](https://pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-model-across-devices) nella *PyTorchdocumentazione*. ## SageMaker Il processo di formazione distribuito dall'IA si blocca durante l'inizializzazione Se il processo di formazione parallela dei dati distribuiti dall' SageMaker intelligenza artificiale si blocca durante l'inizializzazione quando si utilizzano istanze abilitate per EFA, ciò potrebbe essere dovuto a un'errata configurazione nel gruppo di sicurezza della sottorete VPC utilizzata per il processo di formazione. EFA richiede una corretta configurazione del gruppo di sicurezza per abilitare il traffico tra i nodi. **Per configurare regole in entrata e in uscita per il gruppo di sicurezza** 1. Accedi Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Nel riquadro di navigazione a sinistra, scegli **Gruppi di sicurezza**. 1. Seleziona il gruppo di sicurezza collegato alla sottorete VPC che usi per l’addestramento. 1. Nella sezione **Dettagli**, copia l’**ID del gruppo di sicurezza**. 1. Nella scheda **Inbound rules (Regole in entrata)**, seleziona **Edit inbound rules (Modifica regole in entrata)**. 1. Nella pagina **Edit inbound rules (Modifica regole in entrata)**, esegui queste operazioni: 1. Scegliere **Add rule** (Aggiungi regola). 1. In **Type (Tipo)**, selezionare **All traffic (Tutto il traffico)**. 1. Per **Origine**, scegli **Personalizzato**, incolla l'ID del gruppo di sicurezza nella casella di ricerca e seleziona il gruppo di sicurezza che viene visualizzato. 1. Scegli **Salva regole** per completare la configurazione della regola in entrata per il gruppo di sicurezza. 1. Dalla scheda **Regole in uscita**, seleziona **Modifica regole in uscita**. 1. Ripeti le fasi 6 e 7 per aggiungere la stessa regola di una regola in uscita. Dopo aver completato le fasi precedenti per configurare il gruppo di sicurezza con le regole in entrata e in uscita, esegui nuovamente il job di addestramento e verifica se il problema relativo al blocco è stato risolto. Per ulteriori informazioni sui gruppi di sicurezza per VPC ed EFA, consulta [Gruppi di sicurezza per VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) ed [Elastic Fabric Adapter](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). ## SageMaker L'IA distribuiva il lavoro di formazione si interrompe alla fine della formazione Una delle cause principali dei problemi di stallo al termine dell'addestramento è la mancata corrispondenza nel numero di batch elaborati per epoca nelle diverse classificazioni. Tutti i worker (GPUs) sincronizzano i gradienti locali nel passaggio all'indietro per garantire che tutti abbiano la stessa copia del modello al termine dell'iterazione del batch. Se le dimensioni dei lotti vengono assegnate in modo non uniforme ai diversi gruppi di worker durante l'ultima fase dell’addestramento, il processo di addestramento si blocca. Ad esempio, mentre un gruppo di worker (gruppo A) termina l'elaborazione di tutti i batch ed esce dal ciclo di addestramento, un altro gruppo di worker (gruppo B) inizia a elaborare un altro batch e si aspetta comunque che la comunicazione dal gruppo A sincronizzi i gradienti. Ciò fa sì che il gruppo B attenda il gruppo A, che ha già completato l'addestramento e non ha gradienti da sincronizzare. Pertanto, quando si configura il set di dati di addestramento, è importante che ogni worker riceva lo stesso numero di campioni di dati in modo che ogni worker esegua lo stesso numero di batch durante l'addestramento. Assicurati che ogni livello riceva lo stesso numero di batch per evitare questo problema di blocco. ## Osservazione del degrado dell'efficienza di scalabilità dovuto alle difficoltà di throughput di Amazon FSx Una potenziale causa della riduzione dell'efficienza di scalabilità è il limite di velocità effettiva. FSx Se notate un calo improvviso dell'efficienza di scalabilità quando passate a un cluster di formazione più grande, provate a utilizzare un file system FSx for Lustre più grande con un limite di throughput più elevato. Per ulteriori informazioni, consulta [Aggregate file system Performance](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) e [Managing storage and throughput capacity](https://docs.aws.amazon.com/fsx/latest/LustreGuide/managing-storage-capacity.html) nella *Amazon FSx for Lustre User Guide*. ## SageMaker Lavoro di formazione distribuito basato sull'intelligenza artificiale con PyTorch restituisce avvisi di obsolescenza Dalla versione 1.4.0, la libreria di parallelismo dei dati distribuiti SageMaker AI funziona come backend di sistemi distribuiti. PyTorch A causa dell'importante modifica apportata all'utilizzo della libreria con PyTorch, è possibile che venga visualizzato un messaggio di avviso indicante che i pacchetti `smdistributed` APIs per il PyTorch pacchetto distribuito sono obsoleti. Il messaggio di avviso visualizzato dovrebbe essere simile al seguente: ``` smdistributed.dataparallel.torch.dist is deprecated in the SageMaker AI distributed data parallel library v1.4.0+. Please use torch.distributed and specify 'smddp' as a backend when initializing process group as follows: torch.distributed.init_process_group(backend='smddp') For more information, see the library's API documentation at https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-modify-sdp-pt.html ``` Nella versione 1.4.0 e successive, la libreria deve essere importata solo una volta nella parte superiore dello script di formazione e impostata come backend durante l'inizializzazione distribuita. PyTorch Con la singola riga di specifiche del backend, è possibile mantenere invariato lo script di PyTorch formazione e utilizzare direttamente i moduli distribuiti. PyTorch Vedi [Utilizzate la libreria SMDDP nello script di addestramento PyTorch](data-parallel-modify-sdp-pt.md) per scoprire le ultime modifiche e il nuovo modo di usare la libreria con. PyTorch # SageMaker Note di rilascio della libreria di parallelismo dei dati AI Consulta le seguenti note di rilascio per tenere traccia degli ultimi aggiornamenti per la libreria SageMaker AI Distributed Data Parallelism (SMDDP). ## La libreria di parallelismo dei SageMaker dati distribuiti AI v2.5.0 *Data: 17 ottobre 2024* **Nuove funzionalità** + È stato aggiunto il supporto per la v2.4.1 con CUDA PyTorch v12.1. **Integrazione nei contenitori Docker distribuiti dalla libreria SageMaker AI Model Parallelism (SMP)** Questa versione della libreria SMDDP è stata migrata a [La libreria di parallelismo dei modelli v2.6.0 SageMaker](model-parallel-release-notes.md#model-parallel-release-notes-20241017). ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` Per le Regioni in cui sono disponibili le immagini Docker SMP, consulta [Regioni AWS](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **File binario di questa versione** È possibile scaricare o installare la libreria utilizzando l’URL seguente. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.4.1/cu121/2024-10-09/smdistributed_dataparallel-2.5.0-cp311-cp311-linux_x86_64.whl ``` ## La libreria di parallelismo dei SageMaker dati distribuiti AI v2.3.0 *Data: 11 giugno 2024* **Nuove funzionalità** + Aggiunto il supporto per la PyTorch v2.3.0 con CUDA v12.1 e Python v3.11. + È stato aggiunto PyTorch il supporto per Lightning v2.2.5. Questo è integrato nel contenitore del framework SageMaker AI per la versione 2.3.0. PyTorch + Aggiunta la convalida del tipo di istanza durante l’importazione per impedire il caricamento della libreria SMDDP su tipi di istanza non supportati. Per un elenco dei tipi di istanza compatibili con la libreria SMDDP, consulta [Framework e tipi di Regioni AWS istanze supportati](distributed-data-parallel-support.md). **Integrazione nei contenitori SageMaker AI Framework** Questa versione della libreria SMDDP viene migrata al seguente [SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) Framework Container. + PyTorch v2.3.0 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker ``` Per un elenco completo delle versioni della libreria SMDDP e dei container predefiniti, consulta [Framework e tipi di Regioni AWS istanze supportati](distributed-data-parallel-support.md). **File binario di questa versione** È possibile scaricare o installare la libreria utilizzando l’URL seguente. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed_dataparallel-2.3.0-cp311-cp311-linux_x86_64.whl ``` **Altre modifiche** + La libreria SMDDP v2.2.0 è integrata nel contenitore del framework AI per la SageMaker v2.2.0. PyTorch ## La SageMaker libreria di parallelismo dei dati distribuiti AI v2.2.0 *Data: 4 marzo 2024* **Nuove funzionalità** + È stato aggiunto il supporto per la v2.2.0 con CUDA PyTorch v12.1. **Integrazione nei contenitori Docker distribuiti dalla libreria SageMaker AI Model Parallelism (SMP)** Questa versione della libreria SMDDP è stata migrata a [La libreria di SageMaker parallelismo dei modelli v2.2.0](model-parallel-release-notes.md#model-parallel-release-notes-20240307). ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` Per le Regioni in cui sono disponibili le immagini Docker SMP, consulta [Regioni AWS](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **File binario di questa versione** È possibile scaricare o installare la libreria utilizzando l’URL seguente. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed_dataparallel-2.2.0-cp310-cp310-linux_x86_64.whl ``` ## La libreria di parallelismo dei SageMaker dati distribuiti AI v2.1.0 *Data: 1° marzo 2024* **Nuove funzionalità** + È stato aggiunto il supporto per la v2.1.0 con CUDA PyTorch v12.1. **Correzioni di bug** + Risolto il problema di perdita di memoria della CPU in [SMDDP v2.0.1](#data-parallel-release-notes-20231207). **Integrazione in AI Framework Containers SageMaker ** [Questa versione della libreria SMDDP ha superato i test di benchmark ed è stata migrata al seguente SageMaker AI Framework Container.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) + PyTorch v2.1.0 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker ``` **Integrazione in contenitori Docker distribuiti dalla libreria SageMaker AI Model Parallelism (SMP)** Questa versione della libreria SMDDP è stata migrata a [La libreria di SageMaker parallelismo dei modelli v2.1.0](model-parallel-release-notes.md#model-parallel-release-notes-20240206). ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 ``` Per le Regioni in cui sono disponibili le immagini Docker SMP, consulta [Regioni AWS](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **File binario di questa versione** È possibile scaricare o installare la libreria utilizzando l’URL seguente. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed_dataparallel-2.1.0-cp310-cp310-linux_x86_64.whl ``` ## La libreria di parallelismo dei SageMaker dati distribuiti AI v2.0.1 *Data: 7 dicembre 2023* **Nuove funzionalità** + Aggiunta una nuova implementazione SMDDP del funzionamento `AllGather` collettivo ottimizzato per le risorse di calcolo e l'infrastruttura di rete. AWS Per ulteriori informazioni, consulta [Operazione collettiva `AllGather` SMDDP](data-parallel-intro.md#data-parallel-allgather). + L'operazione `AllGather` collettiva SMDDP è compatibile con FSDP e. PyTorch DeepSpeed Per ulteriori informazioni, consulta [Utilizzate la libreria SMDDP nello script di addestramento PyTorch](data-parallel-modify-sdp-pt.md). + È stato aggiunto il supporto per la versione 2.0.1 PyTorch **Problemi noti** + Si verifica un problema di perdita di memoria della CPU a causa di un aumento graduale della memoria della CPU durante l’addestramento con `AllReduce` SMDDP in modalità DDP. **Integrazione in SageMaker AI Framework Containers** [Questa versione della libreria SMDDP ha superato i test di benchmark ed è stata migrata al seguente SageMaker AI Framework Container.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) + PyTorch v2.0.1 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker ``` **File binario di questa versione** È possibile scaricare o installare la libreria utilizzando l’URL seguente. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed_dataparallel-2.0.2-cp310-cp310-linux_x86_64.whl ``` **Altre modifiche** + A partire da questa versione, la documentazione per la libreria SMDDP è completamente disponibile in questa *Amazon SageMaker AI Developer Guide*. A favore della guida completa per gli sviluppatori per SMDDP v2 contenuta nella *Amazon SageMaker AI Developer Guide*, la documentazione per il [riferimento aggiuntivo per SMDDP v1.x nella](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html) documentazione AI *SageMaker Python* SDK non è più supportata. [Se hai ancora bisogno della documentazione SMP v1.x, consulta la seguente istantanea della documentazione nella documentazione di Python SageMaker SDK v2.212.0.](https://sagemaker.readthedocs.io/en/v2.212.0/api/training/distributed.html#the-sagemaker-distributed-data-parallel-library) # Libreria SageMaker Model Parallelism v2 **Nota** Dopo il rilascio della libreria SageMaker Model Parallelism (SMP) v2.0.0 il 19 dicembre 2023, questa documentazione è stata rinnovata per la libreria SMP v2. Per le versioni precedenti della libreria SMP, vedi [(Archiviata) Libreria SageMaker Model Parallelism v1.x](model-parallel.md). La libreria di parallelizzazione dei modelli di Amazon SageMaker AI è una funzionalità di SageMaker AI che consente un addestramento ottimizzato ad alte prestazioni e su larga scala su istanze a calcolo accelerato di SageMaker AI. [Caratteristiche principali della libreria di parallelismo dei SageMaker modelli v2](model-parallel-core-features-v2.md) include tecniche e ottimizzazioni che accelerano e semplificano l’addestramento dei modelli di grandi dimensioni, come la parallelizzazione ibrida dei dati sottoposti a sharding, la parallelizzazione tensoriale, il checkpoint di attivazione e l’offload di attivazione. È possibile utilizzare la libreria SMP per accelerare l’addestramento e il fine-tuning di modelli linguistici di grandi dimensioni (LLM), modelli di visione di grandi dimensioni (LVM) e modelli di fondazione (FM) con centinaia di miliardi di parametri. La libreria SageMaker Model Parallelism v2 (SMP v2) allinea i metodi e le API della libreria con PyTorch Fully Sharded Data Parallelism (FSDP) open source, che consente di ottimizzare le prestazioni SMP con modifiche minime al codice. Con SMP v2, puoi migliorare le prestazioni di calcolo dell’addestramento di un modello di grandi dimensioni all’avanguardia su SageMaker AI, trasferendo gli script di addestramento PyTorch FSDP su SageMaker AI. È possibile utilizzare SMP v2 per i processi di [SageMaker Training](train-model.md) generali e i carichi di lavoro di addestramento distribuito sui cluster [Amazon SageMaker HyperPod](sagemaker-hyperpod.md). **Topics** + [Concetti della parallelizzazione dei modelli](model-parallel-intro-v2.md) + [Framework supportati e Regioni AWS](distributed-model-parallel-support-v2.md) + [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md) + [Caratteristiche principali della libreria di parallelismo dei SageMaker modelli v2](model-parallel-core-features-v2.md) + [Esempi di Amazon SageMaker AI Model Parallelism Library v2](distributed-model-parallel-v2-examples.md) + [SageMaker best practice per il parallelismo dei modelli distribuiti](model-parallel-best-practices-v2.md) + [Il riferimento alla libreria parallela del SageMaker modello v2](distributed-model-parallel-v2-reference.md) + [Note di rilascio per la libreria di parallelismo dei SageMaker modelli](model-parallel-release-notes.md) + [(Archiviata) Libreria SageMaker Model Parallelism v1.x](model-parallel.md) # Concetti della parallelizzazione dei modelli Il parallelismo dei modelli è un metodo di formazione distribuito in cui il modello di deep learning (DL) è suddiviso su più istanze. GPUs La SageMaker model parallel library v2 (SMP v2) è compatibile con le funzionalità native PyTorch APIs . In questo modo è facile adattare lo script di formazione PyTorch Fully Sharded Data Parallel (FSDP) alla piattaforma Training e sfruttare il SageMaker miglioramento delle prestazioni offerto da SMP v2. In questa pagina introduttiva sono disponibili una panoramica generale della parallelizzazione dei modelli e una descrizione di come questa può aiutare a superare i problemi che sorgono durante l’addestramento di modelli di deep learning (DL), che in genere sono di dimensioni molto grandi. Fornisce inoltre esempi di ciò che offre la libreria parallela del SageMaker modello per aiutare a gestire le strategie parallele dei modelli e il consumo di memoria. ## Cos’è la parallelizzazione dei modelli? L'aumento delle dimensioni dei modelli di deep learning (livelli e parametri) consente di ottenere una maggiore precisione per attività complesse come la visione artificiale e l'elaborazione del linguaggio naturale. Tuttavia, esiste un limite alla dimensione massima del modello che è possibile inserire nella memoria di una singola GPU. Durante l'addestramento dei modelli DL, le limitazioni della memoria della GPU possono rappresentare un ostacolo nei seguenti modi: + Limitano le dimensioni del modello che è possibile addestrare, poiché l’ingombro di memoria di un modello si ridimensiona proporzionalmente al numero di parametri. + Limitano la dimensione del batch per GPU durante l'addestramento, riducendo l'utilizzo della GPU e l'efficienza dell'addestramento. Per superare i limiti associati all'addestramento di un modello su una singola GPU, l' SageMaker IA fornisce la libreria parallela di modelli per aiutare a distribuire e addestrare i modelli DL in modo efficiente su più nodi di calcolo. Inoltre, con la libreria, è possibile ottenere un addestramento distribuito ottimizzato utilizzando dispositivi supportati da EFA, che migliorano le prestazioni della comunicazione tra i nodi con bassa latenza, throughput elevato e bypass del sistema operativo. ## Stima dei requisiti di memoria prima di utilizzare la parallelizzazione dei modelli Prima di utilizzare la libreria SageMaker model parallel, considera quanto segue per avere un'idea dei requisiti di memoria necessari per l'addestramento di modelli DL di grandi dimensioni. Per un processo di formazione che utilizza la precisione mista automatica come `float16` (FP16) or `bfloat16` (BF16) e gli ottimizzatori Adam, la memoria GPU richiesta per parametro è di circa 20 byte, che possiamo suddividere come segue: + Un BF16 parametro FP16 or \$1 2 byte + Un BF16 gradiente FP16 or \$1 2 byte + Uno stato di FP32 ottimizzazione di \$1 8 byte basato sugli ottimizzatori Adam + Una FP32 copia del parametro \$1 4 byte (necessaria per il funzionamento (OA`optimizer apply`)) + Una FP32 copia di gradient \$1 4 byte (necessaria per il funzionamento OA) Anche per un modello DL relativamente piccolo con 10 miliardi di parametri, possono essere necessari almeno 200 GB di memoria, che è una dimensione molto più grande della tipica memoria GPU (ad esempio, NVIDIA A100 con 40/80 GB di memoria) disponibile su una singola GPU. Oltre ai requisiti di memoria per gli stati del modello e dell’ottimizzatore, occorre tenere in considerazione anche altri consumatori di memoria, come le attivazioni generate nel passaggio in avanti. La memoria richiesta può essere molto superiore a 200 GB. Per la formazione distribuita, ti consigliamo di utilizzare istanze Amazon EC2 P4 e P5 con NVIDIA A100 e H100 Tensor Core rispettivamente. GPUs Per ulteriori dettagli sulle specifiche quali core della CPU, RAM, volume di archiviazione collegato e larghezza di banda della rete, consulta la sezione *Elaborazione accelerata* nella pagina [Tipi di istanze Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Per informazioni sui tipi di istanza supportati da SMP v2, consulta [Tipi di istanze supportati](distributed-model-parallel-support-v2.md#distributed-model-parallel-supported-instance-types-v2). Anche con le istanze a calcolo accelerato, i modelli con circa 10 miliardi di parametri, come Megatron-LM e T5, e i modelli ancora più grandi con centinaia di miliardi di parametri, come GPT-3, non possono contenere repliche di modelli in ogni dispositivo GPU. ## In che modo la libreria utilizza la parallelizzazione dei modelli e le tecniche di risparmio della memoria La libreria comprende vari tipi di funzionalità di parallelismo dei modelli e funzionalità di risparmio di memoria come il partizionamento dello stato dell'ottimizzatore, il checkpoint di attivazione e l'offload dell'attivazione. Tutte queste tecniche possono essere combinate per addestrare in modo efficiente modelli di grandi dimensioni composti da centinaia di miliardi di parametri. **Topics** + [Parallelizzazione dei dati sottoposti a sharding](#model-parallel-intro-sdp-v2) + [Parallelizzazione degli esperti](#model-parallel-intro-expert-parallelism-v2) + [Parallelizzazione tensoriale](#model-parallel-intro-tp-v2) + [Checkpoint e offload di attivazione](#model-parallel-intro-activation-offloading-checkpointing-v2) + [Scelta delle tecniche giuste per il modello](#model-parallel-intro-choosing-techniques-v2) ### Parallelizzazione dei dati sottoposti a sharding 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) all'interno di un gruppo parallelo di dati. GPUs SMP v2 implementa la parallelizzazione dei dati sottoposti a sharding tramite FSDP e la estende per implementare la strategia di sharding ibrido scalabile discussa nel post del blog [Near-linear scaling of gigantic-model training on AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws). Puoi applicare la parallelizzazione dei dati sottoposti a sharding al modello come strategia standalone. Inoltre, se utilizzi le istanze GPU più performanti dotate di NVIDIA A100 Tensor Core GPUs`ml.p4de.24xlarge`, `ml.p4d.24xlarge` puoi trarre vantaggio dalla maggiore velocità di formazione derivante dalle `AllGather` operazioni offerte dalla [libreria SageMaker Data Parallelism (SMDDP)](data-parallel.md). Per approfondire la parallelizzazione dei dati sottoposti a sharding e imparare a configurarla o utilizzarla in combinazione con altre tecniche come la parallelizzazione tensoriale e l’addestramento di precisione misto, consulta [Parallelizzazione dei dati sottoposti a sharding](model-parallel-core-features-v2-sharded-data-parallelism.md). ### Parallelizzazione degli esperti *SMP v2 si integra con [NVIDIA](https://github.com/NVIDIA/Megatron-LM) Megatron per implementare il parallelismo esperto oltre al supporto per l'FSDP nativo.* PyTorch APIs *Puoi mantenere il codice di formazione PyTorch FSDP così com'è e applicare il parallelismo degli esperti SMP per addestrare i modelli Mixture of Experts (MoE) all'interno dell'IA.* SageMaker Un modello MoE è un tipo di modello di trasformatore composto da più *esperti*, ciascuno costituito da una rete neurale, in genere una rete feed-forward (FFN). Una rete di porte chiamata *router* determina quali token vengono inviati a quale esperto. Gli esperti sono specializzati nell’elaborazione di aspetti specifici dei dati di input, per consentire un addestramento più rapido del modello e una riduzione dei costi di calcolo, ottenendo al contempo la stessa qualità delle prestazioni del modello ad alta densità equivalente. Inoltre, la *parallelizzazione degli esperti* è una tecnica di parallelizzazione che consente di suddividere gli esperti di un modello MoE tra dispositivi GPU. Per informazioni su come addestrare i modelli MoE con SMP v2, consulta [Parallelizzazione degli esperti](model-parallel-core-features-v2-expert-parallelism.md). ### Parallelizzazione tensoriale La *parallelizzazione tensoriale* divide i singoli livelli, o `nn.Modules`, tra dispositivi, per essere eseguiti in parallelo. La figura seguente mostra l’esempio più semplice di come la libreria divide un modello con quattro livelli per ottenere una parallelizzazione tensoriale bidirezionale (`"tensor_parallel_degree": 2`). Nella figura seguente, le notazioni per il gruppo parallelo di modelli, il gruppo parallelo di tensori e il gruppo parallelo di dati sono `MP_GROUP`, `TP_GROUP` e `DP_GROUP` rispettivamente. I livelli di ogni replica del modello sono divisi in due e distribuiti in due. GPUs La libreria gestisce la comunicazione tra le repliche del modello distribuite dai tensori. ![\[L’esempio più semplice di come la libreria SMP divide un modello con quattro livelli per ottenere una parallelizzazione tensoriale bidirezionale (“tensor_parallel_degree”: 2).\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/smp-v2-tensor-parallel.png) Per approfondire il parallelismo tensoriale e altre funzionalità di risparmio di memoria e per imparare a impostare una combinazione delle funzionalità principali PyTorch, consulta. [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md) ### Checkpoint e offload di attivazione Per risparmiare memoria della GPU, la libreria supporta il checkpoint di attivazione per evitare di memorizzare le attivazioni interne nella memoria della GPU per i moduli specificati dall'utente durante il passaggio in avanti. La libreria ricalcola queste attivazioni durante il passaggio all'indietro. Inoltre, la funzione di offload dell’attivazione le consente di eseguire l’offload delle attivazioni archiviate nella memoria della CPU e recuperarle sulla GPU durante il passaggio all’indietro, in modo da ridurre ulteriormente l’ingombro della memoria di attivazione. Per ulteriori informazioni su come utilizzare queste funzionalità, consulta [Checkpoint di attivazione](model-parallel-core-features-v2-pytorch-activation-checkpointing.md) e [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md). ### Scelta delle tecniche giuste per il modello Per ulteriori informazioni sulla scelta delle tecniche e delle configurazioni corrette, consulta [SageMaker best practice per il parallelismo dei modelli distribuiti](model-parallel-best-practices-v2.md). # Framework supportati e Regioni AWS Prima di utilizzare la SageMaker model parallelism library v2 (SMP v2), controlla i framework e i tipi di istanza supportati e determina se ci sono quote sufficienti nel tuo account e. AWS Regione AWS **Nota** Per controllare gli ultimi aggiornamenti e le note di rilascio della libreria, consulta [Note di rilascio per la libreria di parallelismo dei SageMaker modelli](model-parallel-release-notes.md). ## Framework supportati SMP v2 supporta i seguenti framework di deep learning ed è disponibile tramite i container Docker SMP e un canale Conda di SMP. Quando si utilizzano le classi di stima del framework in SageMaker Python SDK e si specifica la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. Per usare SMP v2, ti consigliamo di mantenere sempre aggiornato l'SDK SageMaker Python nel tuo ambiente di sviluppo. **PyTorch versioni supportate dalla libreria Model SageMaker Parallelism** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/distributed-model-parallel-support-v2.html) **Canale Conda di SMP** Il seguente bucket Amazon S3 è un canale Conda pubblico ospitato dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. ``` https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/ ``` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. **Nota** *Per trovare le versioni precedenti della libreria SMP v1.x e quelle DLCs preconfezionate, consultate la documentazione SMP v1. [Framework supportati](distributed-model-parallel-support.md#distributed-model-parallel-supported-frameworks)* ### Utilizzo di SMP v2 con librerie open source La libreria SMP v2 funziona con altre PyTorch librerie open source come PyTorch Lightning, Hugging Face Transformers e Hugging Face Accelerate, poiché SMP v2 è compatibile con FSDP. PyTorch APIs Se hai ulteriori domande sull’utilizzo della libreria SMP con altre librerie di terze parti, contatta il team di assistenza SMP all’indirizzo `sm-model-parallel-feedback@amazon.com`. ## Regioni AWS SMP v2 è disponibile nelle versioni seguenti. Regioni AWS Se desideri utilizzare l'immagine SMP Docker URIs o il canale SMP Conda, controlla il seguente elenco e scegli quello Regione AWS che corrisponde al tuo e aggiorna l'URI dell'immagine o l'URL del canale di conseguenza. + ap-northeast-1 + ap-northeast-2 + ap-northeast-3 + ap-south-1 + ap-southeast-1 + ap-southeast-2 + ca-central-1 + eu-central-1 + eu-north-1 + eu-west-1 + eu-west-2 + eu-west-3 + sa-east-1 + us-east-1 + us-east-2 + us-west-1 + us-west-2 ## Tipi di istanze supportati SMP v2 richiede uno dei seguenti tipi di istanza ML. | Tipo di istanza | | --- | | ml.p4d.24xlarge | | ml.p4de.24xlarge | | ml.p5.48xlarge | | ml.p5e.48xlarge | **Suggerimento** A partire da SMP v2.2.0, è disponibile il supporto PyTorch per la versione 2.2.0 e successive. [Addestramento di precisione misto con nessuna istanza P5 utilizzando Transformer Engine FP8](model-parallel-core-features-v2-mixed-precision.md#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5) Per le specifiche dei tipi di istanze di SageMaker machine learning in generale, consulta la sezione **Accelerated Computing** nella pagina Tipi di [istanze Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Per informazioni sui prezzi delle istanze, consulta la pagina [dei prezzi di Amazon SageMaker AI](https://aws.amazon.com/sagemaker/pricing/). Se hai ricevuto un messaggio di errore simile al seguente, applica le istruzioni fornite nella sezione [Richiesta di aumento delle quote](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) nella *Guida per l’utente di AWS Service Quotas*. ``` ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling the CreateTrainingJob operation: The account-level service limit 'ml.p3dn.24xlarge for training job usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please contact AWS support to request an increase for this limit. ``` # Usa la libreria di parallelismo dei SageMaker modelli v2 In questa pagina, imparerai come utilizzare la libreria di parallelismo dei SageMaker modelli v2 APIs e iniziare a eseguire un processo di formazione PyTorch Fully Sharded Data Parallel (FSDP) nella piattaforma di formazione o su un cluster. SageMaker SageMaker HyperPod Esistono vari scenari per eseguire un PyTorch processo di formazione con SMP v2. 1. Per la SageMaker formazione, utilizza uno dei SageMaker Framework Containers predefiniti per la versione PyTorch 2.0.1 e successive, preconfezionati con SMP v2. 1. Utilizzate il file binario SMP v2 per configurare un ambiente Conda per l'esecuzione di un carico di lavoro di formazione distribuito su un cluster. SageMaker HyperPod 1. Estendi i SageMaker Framework Containers predefiniti per la PyTorch versione 2.0.1 e successive per installare eventuali requisiti funzionali aggiuntivi per il tuo caso d'uso. Per informazioni su come estendere un container predefinito, consulta [Estensione di un container predefinito](prebuilt-containers-extend.md). 1. Puoi anche portare il tuo contenitore Docker e configurare manualmente tutto l'ambiente di formazione utilizzando il [toolkit SageMaker](https://github.com/aws/sagemaker-training-toolkit) Training e installare il SageMaker file binario SMP v2. Questa è l’opzione meno consigliata a causa della complessità delle dipendenze. Per informazioni su come gestire il tuo container Docker, consulta [Adattamento del container di addestramento](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html). Questa guida introduttiva copre i primi due scenari. **Topics** + [Fase 1: Adatta lo script di formazione FSDP PyTorch](#model-parallel-adapt-pytorch-script-v2) + [Fase 2: avvio di un job di addestramento](#model-parallel-launch-a-training-job-v2) ## Fase 1: Adatta lo script di formazione FSDP PyTorch Per attivare e configurare la libreria SMP v2, inizia importando e aggiungendo il modulo `torch.sagemaker.init()` nella parte superiore dello script. Questo modulo include il dizionario di configurazione di SMP [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) da utilizzare per la preparazione in [Fase 2: avvio di un job di addestramento](#model-parallel-launch-a-training-job-v2). Inoltre, per utilizzare le varie funzionalità principali offerte da SMP v2, potrebbe essere necessario apportare qualche altra modifica per adattare lo script di addestramento. Istruzioni più dettagliate sull’adattamento dello script di addestramento per l’utilizzo delle funzionalità principali di SMP v2 sono disponibili all’indirizzo [Caratteristiche principali della libreria di parallelismo dei SageMaker modelli v2](model-parallel-core-features-v2.md). ------ #### [ SageMaker Training ] Nello script di addestramento, aggiungi le seguenti due righe di codice, che rappresentano il requisito minimo per iniziare l’addestramento con SMP v2. In[Fase 2: avvio di un job di addestramento](#model-parallel-launch-a-training-job-v2), imposterai un oggetto della classe SageMaker `PyTorch` estimator con un dizionario di configurazione SMP tramite l'`distribution`argomento della classe estimator. ``` import torch.sagemaker as tsm tsm.init() ``` **Nota** È anche possibile passare direttamente un dizionario di configurazione di [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) al modulo `torch.sagemaker.init()`. Tuttavia, i parametri passati allo PyTorch stimatore hanno la priorità e [Fase 2: avvio di un job di addestramento](#model-parallel-launch-a-training-job-v2) sostituiscono quelli specificati nel modulo. `torch.sagemaker.init()` ------ #### [ SageMaker HyperPod ] Nello script di addestramento, aggiungi le seguenti due righe di codice. In [Fase 2: avvio di un job di addestramento](#model-parallel-launch-a-training-job-v2) seguito, configurerai un `smp_config.json` file per configurare le configurazioni SMP in formato JSON e lo caricherai su uno storage o su un file system mappato con il tuo cluster. SageMaker HyperPod Ti consigliamo di conservare il file di configurazione nella stessa directory in cui carichi lo script di addestramento. ``` import torch.sagemaker as tsm tsm.init("/dir_to_training_files/smp_config.json") ``` **Nota** È anche possibile passare direttamente un dizionario di configurazione di [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) al modulo `torch.sagemaker.init()`. ------ ## Fase 2: avvio di un job di addestramento Scopri come configurare le opzioni di distribuzione SMP per avviare un processo di formazione PyTorch FSDP con le funzionalità principali di SMP. ------ #### [ SageMaker Training ] Quando imposti un oggetto training job launcher della classe [PyTorch framework estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html) in SageMaker Python SDK, configura [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) tramite argument come segue. `distribution` **Nota** La `distribution` configurazione per SMP v2 è integrata nell'SDK SageMaker Python a partire dalla v2.200. Assicurati di utilizzare SageMaker Python SDK v2.200 o successivo. **Nota** In SMP v2, è necessario configurare `smdistributed` con `torch_distributed` per l'argomento dello stimatore. `distribution` SageMaker `PyTorch` [Con`torch_distributed`, SageMaker AI run`torchrun`, che è il job launcher multi-nodo predefinito di Distributed. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( framework_version=2.2.0, py_version="310" # image_uri="" # For using prior versions, specify the SMP image URI directly. entry_point="your-training-script.py", # Pass the training script you adapted with SMP from Step 1. ... # Configure other required and optional parameters distribution={ "torch_distributed": { "enabled": True }, "smdistributed": { "modelparallel": { "enabled": True, "parameters": { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } } } } ) ``` **Importante** Per utilizzare una delle versioni precedenti PyTorch o SMP anziché la più recente, è necessario specificare l'immagine SMP Docker direttamente utilizzando l'`image_uri`argomento anziché la coppia and. `framework_version` `py_version` Di seguito è riportato un esempio di ``` estimator = PyTorch( ..., image_uri="658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121" ) ``` Per trovare l'immagine SMP Docker, vedere. URIs [Framework supportati](distributed-model-parallel-support-v2.md#distributed-model-parallel-supported-frameworks-v2) ------ #### [ SageMaker HyperPod ] Prima di iniziare, verifica che siano soddisfatti i requisiti preliminari indicati di seguito. + Una directory FSx condivisa Amazon montata (`/fsx`) sul tuo HyperPod cluster. + Conda installato nella directory FSx condivisa. Per informazioni su come installare Conda, utilizza le istruzioni riportate in [Installazione su Linux](https://docs.conda.io/projects/conda/en/latest/user-guide/install/linux.html) nella *Guida per l’utente di Conda*. + `cuda11.8`o `cuda12.1` installato sui nodi principali e di calcolo del cluster HyperPod . Se tutti i prerequisiti sono soddisfatti, segui le seguenti istruzioni sull'avvio di un carico di lavoro con SMP v2 su un cluster. HyperPod 1. Prepara un file `smp_config.json` che contenga un dizionario di [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). Assicurati di caricare questo file JSON nella posizione in cui archivi lo script di addestramento o nel percorso specificato per il modulo `torch.sagemaker.init()` nella [Fase 1](#model-parallel-adapt-pytorch-script-v2). Se hai già passato il dizionario di configurazione al modulo `torch.sagemaker.init()` nello script di addestramento durante la [Fase 1](#model-parallel-adapt-pytorch-script-v2), puoi saltare questa fase. ``` // smp_config.json { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } ``` 1. Carica il file `smp_config.json` in una directory del tuo file system. Il percorso della directory deve corrispondere al percorso specificato nella [Fase 1](#model-parallel-adapt-pytorch-script-v2). Se hai già passato il dizionario di configurazione al modulo `torch.sagemaker.init()` nello script di addestramento, puoi saltare questa fase. 1. Sui nodi di calcolo del cluster, avvia una sessione di terminale con il seguente comando. ``` sudo su -l ubuntu ``` 1. Crea un ambiente Conda sui nodi di calcolo. Il codice seguente è uno script di esempio per creare un ambiente Conda e installare SMP, [SMDDP](data-parallel.md), CUDA e altre dipendenze. ``` # Run on compute nodes SMP_CUDA_VER=<11.8 or 12.1> source /fsx//miniconda3/bin/activate export ENV_PATH=/fsx//miniconda3/envs/ conda create -p ${ENV_PATH} python=3.10 conda activate ${ENV_PATH} # Verify aws-cli is installed: Expect something like "aws-cli/2.15.0*" aws ‐‐version # Install aws-cli if not already installed # https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html#cliv2-linux-install # Install the SMP library conda install pytorch="2.0.1=sm_py3.10_cuda${SMP_CUDA_VER}*" packaging ‐‐override-channels \ -c https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-2.0.0-pt-2.0.1/2023-12-11/smp-v2/ \ -c pytorch -c numba/label/dev \ -c nvidia -c conda-forge # Install dependencies of the script as below python -m pip install packaging transformers==4.31.0 accelerate ninja tensorboard h5py datasets \ && python -m pip install expecttest hypothesis \ && python -m pip install "flash-attn>=2.0.4" ‐‐no-build-isolation # Install the SMDDP wheel SMDDP_WHL="smdistributed_dataparallel-2.0.2-cp310-cp310-linux_x86_64.whl" \ && wget -q https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/${SMDDP_WHL} \ && pip install ‐‐force ${SMDDP_WHL} \ && rm ${SMDDP_WHL} # cuDNN installation for Transformer Engine installation for CUDA 11.8 # Please download from below link, you need to agree to terms # https://developer.nvidia.com/downloads/compute/cudnn/secure/8.9.5/local_installers/11.x/cudnn-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz tar xf cudnn-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz \ && rm -rf /usr/local/cuda-$SMP_CUDA_VER/include/cudnn* /usr/local/cuda-$SMP_CUDA_VER/lib/cudnn* \ && cp ./cudnn-linux-x86_64-8.9.5.30_cuda11-archive/include/* /usr/local/cuda-$SMP_CUDA_VER/include/ \ && cp ./cudnn-linux-x86_64-8.9.5.30_cuda11-archive/lib/* /usr/local/cuda-$SMP_CUDA_VER/lib/ \ && rm -rf cudnn-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz \ && rm -rf cudnn-linux-x86_64-8.9.5.30_cuda11-archive/ # Please download from below link, you need to agree to terms # https://developer.download.nvidia.com/compute/cudnn/secure/8.9.7/local_installers/12.x/cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz \ # cuDNN installation for TransformerEngine installation for cuda12.1 tar xf cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz \ && rm -rf /usr/local/cuda-$SMP_CUDA_VER/include/cudnn* /usr/local/cuda-$SMP_CUDA_VER/lib/cudnn* \ && cp ./cudnn-linux-x86_64-8.9.7.29_cuda12-archive/include/* /usr/local/cuda-$SMP_CUDA_VER/include/ \ && cp ./cudnn-linux-x86_64-8.9.7.29_cuda12-archive/lib/* /usr/local/cuda-$SMP_CUDA_VER/lib/ \ && rm -rf cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz \ && rm -rf cudnn-linux-x86_64-8.9.7.29_cuda12-archive/ # TransformerEngine installation export CUDA_HOME=/usr/local/cuda-$SMP_CUDA_VER export CUDNN_PATH=/usr/local/cuda-$SMP_CUDA_VER/lib export CUDNN_LIBRARY=/usr/local/cuda-$SMP_CUDA_VER/lib export CUDNN_INCLUDE_DIR=/usr/local/cuda-$SMP_CUDA_VER/include export PATH=/usr/local/cuda-$SMP_CUDA_VER/bin:$PATH export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-$SMP_CUDA_VER/lib python -m pip install ‐‐no-build-isolation git+https://github.com/NVIDIA/TransformerEngine.git@v1.0 ``` 1. Esegui un job di addestramento di prova. 1. Nel file system condiviso (`/fsx`), clona il [ GitHub repository Awsome Distributed Training](https://github.com/aws-samples/awsome-distributed-training/) e vai alla cartella. `3.test_cases/11.modelparallel` ``` git clone https://github.com/aws-samples/awsome-distributed-training/ cd awsome-distributed-training/3.test_cases/11.modelparallel ``` 1. Invia un job utilizzando `sbatch` come segue. ``` conda activate sbatch -N 16 conda_launch.sh ``` Se l’invio del job ha esito positivo, il messaggio di output di questo comando `sbatch` dovrebbe essere simile a `Submitted batch job ABCDEF`. 1. Controlla il file di log nella directory corrente in `logs/`. ``` tail -f ./logs/fsdp_smp_ABCDEF.out ``` ------ # Caratteristiche principali della libreria di parallelismo dei SageMaker modelli v2 La libreria di parallelismo dei modelli Amazon SageMaker AI v2 (SMP v2) offre strategie di distribuzione e tecniche di risparmio della memoria, come il parallelismo dei dati condivisi, il parallelismo tensoriale e il checkpoint. Le strategie e le tecniche di parallelizzazione dei modelli offerte da SMP v2 aiutano a distribuire modelli di grandi dimensioni su più dispositivi, ottimizzando al contempo la velocità di addestramento e il consumo di memoria. SMP v2 fornisce inoltre un pacchetto Python `torch.sagemaker` per contribuire ad adattare lo script di addestramento con poche righe di modifica del codice. Questa guida segue il flusso di base in due fasi introdotto in [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). Per approfondire la conoscenza delle funzionalità principali di SMP v2 e come utilizzarle, consulta i seguenti argomenti. **Nota** Queste funzionalità principali sono disponibili in SMP v2.0.0 e versioni successive e in SageMaker Python SDK v2.200.0 e versioni successive, e funzionano per la versione 2.0.1 e successive. PyTorch Per verificare le versioni dei pacchetti, vedi [Framework supportati e Regioni AWS](distributed-model-parallel-support-v2.md). **Topics** + [Parallelizzazione dei dati sottoposti a sharding](model-parallel-core-features-v2-sharded-data-parallelism.md) + [Parallelizzazione degli esperti](model-parallel-core-features-v2-expert-parallelism.md) + [Parallelizzazione del contesto](model-parallel-core-features-v2-context-parallelism.md) + [Compatibilità con la libreria SMDDP ottimizzata per l'infrastruttura AWS](model-parallel-core-features-v2-smddp-allgather.md) + [Addestramento di precisione misto](model-parallel-core-features-v2-mixed-precision.md) + [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md) + [Checkpoint di attivazione](model-parallel-core-features-v2-pytorch-activation-checkpointing.md) + [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md) + [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md) + [Fine-tuning](model-parallel-core-features-v2-fine-tuning.md) + [FlashAttention](model-parallel-core-features-v2-flashattention.md) + [Checkpointing con SMP](model-parallel-core-features-v2-checkpoints.md) # Parallelizzazione dei dati sottoposti a sharding La *parallelizzazione dei dati sottoposti a sharding* è una tecnica di addestramento distribuito a risparmio di memoria che suddivide lo stato di un modello (parametri del modello, gradienti e stati dell’ottimizzatore) tra i dispositivi. Ciò consente di adattare un modello più grande o di aumentare la dimensione del batch utilizzando la memoria GPU liberata. La libreria SMP offre la capacità di eseguire il parallelismo dei dati condivisi con Fully Sharded Data Parallel (FSDP). PyTorch PyTorch Per impostazione predefinita, FSDP copre l'intero set di frammenti in uso. GPUs [In SMP v2, la libreria offre questo parallelismo di dati frammentati oltre a PyTorch FSDP estendendo lo sharding PyTorch ibrido (`HYBRID_SHARD`), che è una delle strategie di sharding fornite da FSDP:,,,. PyTorch ](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.ShardingStrategy) `FULL_SHARD` `SHARD_GRAD_OP` `HYBRID_SHARD` `_HYBRID_SHARD_ZERO2` [Estendere lo sharding ibrido in questo modo aiuta a implementare scale-aware-sharding, come descritto nel blog, la scalabilità quasi lineare della formazione su modelli gigantici su FSDP. AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) PyTorch La libreria SMP lo rende facile da usare `HYBRID_SHARD` e `_HYBRID_SHARD_ZERO2` su qualsiasi numero configurabile di GPUs, estendendo il PyTorch FSDP nativo che supporta lo sharding su un singolo nodo () o su tutti (). `HYBRID_SHARD` GPUs `FULL_SHARD` PyTorch Le chiamate FSDP possono rimanere invariate ed è sufficiente aggiungere l'`hybrid_shard_degree`argomento alla configurazione SMP, come mostrato nel seguente esempio di codice. Non è necessario modificare il valore dell'`sharding_strategy`argomento nel wrapper PyTorch FSDP del modello. PyTorch Puoi passare `ShardingStrategy.HYBRID_SHARD` come valore. In alternativa, la libreria SMP sovrascrive la strategia dello script e la imposta su `ShardingStrategy.HYBRID_SHARD` se si specifica un valore uguale o maggiore di 2 per il parametro `hybrid_shard_degree`. I seguenti frammenti di codice mostrano come aggiungere il modulo di inizializzazione SMP `torch.sagemaker.init()` allo script di addestramento e impostare il dizionario di configurazione di SMP in formato JSON per il programma di avvio del job di addestramento seguendo il processo in due fasi introdotto in [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). [Non è necessario apportare modifiche al PyTorch modello o alla configurazione FSDP. PyTorch ](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp) Per ulteriori informazioni sul parametro `hybrid_shard_degree`, vedi [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **Dizionario di configurazione di SMP** ``` { "hybrid_shard_degree": 16 } ``` **Nello script di addestramento** ``` import torch.sagemaker as tsm tsm.init() # Set up a PyTorch model model = ... # Wrap the PyTorch model using the PyTorch FSDP module model = FSDP( model, ... ) # Optimizer needs to be created after FSDP wrapper optimizer = ... ``` # Parallelizzazione degli esperti Un modello *Mixture of Experts* (MoE) è un tipo di modello di trasformatore basato su un approccio *sparso*, che lo rende più leggero per l’addestramento rispetto ai modelli densi tradizionali. In questa architettura di rete neurale MoE, per ogni input viene utilizzato solo un sottoinsieme dei componenti del modello denominati *esperti.* Questo approccio offre diversi vantaggi, tra cui un addestramento più efficiente e un’inferenza più rapida, anche con modelli di dimensioni maggiori. In altre parole, con lo stesso budget di calcolo per l’addestramento di un modello a piena densità, puoi adattare un modello o un set di dati più grande utilizzando MoE. Un modello MoE è composto da più *esperti*, ciascuno costituito da una rete neurale, in genere una rete feed-forward (FFN). Una rete di porte chiamata *router* determina quali token vengono inviati a quale esperto. Gli esperti sono specializzati nell’elaborazione di aspetti specifici dei dati di input, per consentire un addestramento più rapido del modello e una riduzione dei costi di calcolo, ottenendo al contempo la stessa qualità delle prestazioni del modello ad alta densità equivalente. Per ulteriori informazioni su Mixture of Experts in generale, fai riferimento al blog [Applying Mixture of Experts in LLM Architectures](https://developer.nvidia.com/blog/applying-mixture-of-experts-in-llm-architectures/) nel *sito web per sviluppatori di NVIDIA*. La *parallelizzazione degli esperti* è un tipo di parallelizzazione che consente di suddividere gli esperti di un modello MoE tra dispositivi GPU. SMP v2 si integra con [NVIDIA Megatron](https://github.com/NVIDIA/Megatron-LM) per implementare il parallelismo esperto per supportare l'addestramento dei modelli MoE e funziona con FSDP. PyTorch APIs Continuate a utilizzare il codice di formazione PyTorch FSDP così com'è e attivate il parallelismo degli esperti SMP per addestrare i modelli MoE. ## Modelli di Hugging Face Transformers compatibili con la parallelizzazione degli esperti SMP SMP v2 offre attualmente il supporto per la parallelizzazione degli esperti per i seguenti modelli di Hugging Face Transformers. + [Mixtral](https://huggingface.co/docs/transformers/en/model_doc/mixtral) ## Configurare la parallelizzazione degli esperti Per `expert_parallel_degree`, seleziona un valore per il grado di parallelizzazione degli esperti. Il valore deve dividere equamente il numero di nel cluster. GPUs Ad esempio, per suddividere il modello utilizzando un'istanza con 8 GPUs, scegliete 2, 4 o 8. È consigliabile iniziare con un numero piccolo e aumentarlo gradualmente fino a quando il modello risulta adatto alla memoria della GPU. I seguenti frammenti di codice mostrano come aggiungere il modulo di inizializzazione SMP `torch.sagemaker.init()` allo script di addestramento e impostare il dizionario di configurazione di SMP in formato JSON per il programma di avvio del job di addestramento seguendo il processo in due fasi introdotto in [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). Non è necessario apportare modifiche al PyTorch modello o alla configurazione [PyTorch FSDP](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp). Per ulteriori informazioni sul parametro `expert_parallel_degree`, vedi [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **Nota** Puoi utilizzare la parallelizzazione degli esperti con [Parallelizzazione dei dati sottoposti a sharding](model-parallel-core-features-v2-sharded-data-parallelism.md). Tieni presente che la parallelizzazione degli esperti non è attualmente compatibile con la parallelizzazione tensoriale. **Nota** Questa funzionalità di formazione per esperti sul parallelismo è disponibile nella seguente combinazione di librerie di SageMaker e libreria: PyTorch SMP v2.3.0 e versioni successive SageMaker Python SDK v2.214.4 e versioni successive PyTorch v2.2.0 e versioni successive ### Nello script di addestramento Durante la [Fase 1](model-parallel-use-api-v2.md#model-parallel-adapt-pytorch-script-v2), inizializza lo script con `torch.sagemaker.init()` per attivare SMP v2 ed eseguire il wrapping del modello con l’API [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform), aggiungendo il parametro `config` all’API per attivare MoE. Il frammento di codice riportato di seguito mostra come attivare MoE di SMP per la classe del modello generico `AutoModelForCausalLM` estraendo una configurazione del modello di trasformatore MoE mediante il metodo `from_config` per l’addestramento da zero o il metodo `from_pretrained` per il fine-tuning. Per ulteriori informazioni sulla classe `MoEConfig` di SMP, vedi [`torch.sagemaker.moe.moe_config.MoEConfig`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-moe). ``` # Import the torch.sagemaker.transform API and initialize. import torch.sagemaker as tsm tsm.init() # Import transformers AutoModelForCausalLM class. from transformers import AutoModelForCausalLM # Import the SMP-implementation of MoE configuration class. from torch.sagemaker.moe.moe_config import MoEConfig # Define a transformer model with an MoE model configuration model = AutoModelForCausalLM.from_config(MoEModelConfig) # Wrap it by torch.sagemaker.transform with the SMP MoE configuration. model = tsm.transform( model, config=MoEConfig( smp_moe=True, random_seed=12345, moe_load_balancing="sinkhorn", global_token_shuffle=False, moe_all_to_all_dispatcher=True, moe_aux_loss_coeff=0.001, moe_z_loss_coeff=0.001 ) ) ``` ### Configurazione di SMP Come parte della [Fase 2](model-parallel-use-api-v2.md#model-parallel-launch-a-training-job-v2), aggiungete il seguente parametro al dizionario di configurazione SMP per lo stimatore. SageMaker PyTorch ``` { ..., # other SMP config parameters "expert_parallel_degree": 8 } ``` # Parallelizzazione del contesto La *parallelizzazione del contesto* è un tipo di parallelizzazione del modello che partiziona le attivazioni del modello lungo la dimensione della sequenza. A differenza di altre tecniche di [parallelizzazione delle sequenze](https://arxiv.org/abs/2205.05198), che si limitano a partizionare `LayerNorm` e `RMSNorm`, la parallelizzazione del contesto partiziona gli input di rete e tutte le attivazioni intermedie lungo la dimensione della sequenza. SMP v2 si integra con [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) per il parallelismo di contesto e può essere utilizzato insieme a FSDP e SMP. PyTorch [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md) Per l’addestramento dei modelli è possibile abilitare tutti e tre i parallelismi contemporaneamente. La parallelizzazione del contesto è utile per addestrare modelli con grandi dimensioni di attivazione e maggiori lunghezze di sequenza. Accelera il calcolo dei punteggi e degli output di attenzione, consentendo a ciascun dispositivo di calcolare solo una parte dei punteggi e degli output lungo la dimensione della sequenza. Sebbene la parallelizzazione tensoriale acceleri anche il calcolo attraverso il partizionamento lungo la dimensione nascosta, il vantaggio della parallelizzazione del contesto è più sostanziale, poiché i requisiti di calcolo aumentano quadraticamente con la dimensione della sequenza. ## Modelli di Hugging Face Transformers compatibili con la parallelizzazione del contesto SMP SMP v2 offre attualmente il supporto per la parallelizzazione del contesto per i seguenti modelli di Hugging Face Transformers. + GPT-NeoX + Llama 2 e Llama 3 + [Mistral 7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) ## Configurazione della parallelizzazione del contesto Imposta un valore intero per il parametro che divide equamente il numero di nel cluster`context_parallel_degree`. GPUs Ad esempio, se disponi di un’istanza con 8 GPU, utilizza 2, 4 o 8 per `context_parallel_degree`. È consigliabile iniziare con un valore `context_parallel_degree` basso e aumentarlo gradualmente fino a quando il modello risulta adatto alla memoria della GPU con la lunghezza della sequenza di input richiesta. I seguenti frammenti di codice mostrano come aggiungere il modulo di inizializzazione SMP `torch.sagemaker.init()` allo script di addestramento e impostare il dizionario di configurazione di SMP in formato JSON per il programma di avvio del job di addestramento seguendo il processo in due fasi introdotto in [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). Non è necessario apportare modifiche al PyTorch modello o alla configurazione [PyTorch FSDP](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp). Per ulteriori informazioni sul parametro `context_parallel_degree`, vedi [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). ### Nello script di addestramento Durante la [Fase 1](model-parallel-use-api-v2.md#model-parallel-adapt-pytorch-script-v2), inizializza lo script con `torch.sagemaker.init()` per attivare SMP v2 ed eseguire il wrapping del modello con l’API [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform). A partire da SMP v2.6.0, è possibile utilizzare l’argomento `cp_comm_type` per determinare quale implementazione di contesto utilizzare. La libreria SMP attualmente supporta due implementazioni: `p2p` e `all_gather`. L'`p2p`implementazione utilizza chiamate di peer-to-peer invio e ricezione per l'accumulo di valori-chiave durante l'implementazione dell'attenzione e viene eseguita in modo asincrono, consentendo sovrapposizioni con l'elaborazione. `all_gather`l'implementazione, invece, utilizza l'operazione collettiva e viene eseguita in modo sincrono. `AllGather` ``` import torch.sagemaker as tsm tsm.init() from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_config(..) model = tsm.transform(model, cp_comm_type="p2p") ``` ### Configurazione di SMP Come parte della [Fase 2](model-parallel-use-api-v2.md#model-parallel-launch-a-training-job-v2), aggiungete il seguente parametro al dizionario di configurazione SMP per lo SageMaker PyTorch stimatore. ``` { ..., # other SMP config parameters "context_parallel_degree": 2 } ``` # Compatibilità con la libreria SMDDP ottimizzata per l'infrastruttura AWS È possibile utilizzare la SageMaker model parallelism library v2 (SMP v2) insieme alla libreria [SageMaker Distributed Data Parallelism (SMDDP](data-parallel.md)) che offre operazioni di comunicazione collettiva ottimizzate per l'infrastruttura. `AllGather` AWS Nell’addestramento distribuito, le operazioni di comunicazione collettiva sono progettate per la sincronizzazione di più worker GPU e lo scambio di informazioni tra di loro. `AllGather` è una delle principali operazioni di comunicazione collettiva tipicamente utilizzate nella parallelizzazione dei dati sottoposti a sharding. Per ulteriori informazioni sul funzionamento SMDDP, vedere L'[Operazione collettiva `AllGather` SMDDP](data-parallel-intro.md#data-parallel-allgather)ottimizzazione di tali `AllGather` operazioni di comunicazione collettiva contribuirebbe direttamente a una formazione più rapida senza effetti collaterali sulla convergenza. end-to-end **Nota** La libreria SMDDP supporta le istanze P4 e P4de (vedi anche [Framework e tipi di Regioni AWS istanze supportati](distributed-data-parallel-support.md) nella libreria SMDDP). [La libreria SMDDP si integra nativamente con il livello del gruppo di processi. PyTorch ](https://pytorch.org/docs/stable/distributed.html) Per utilizzare la libreria SMDDP, è sufficiente aggiungere due righe di codice allo script di addestramento. Supporta qualsiasi framework di formazione come SageMaker Model Parallelism Library, FSDP e. PyTorch DeepSpeed Per attivare SMDDP e utilizzarne l’operazione `AllGather`, è necessario aggiungere due righe di codice allo script di addestramento nell’ambito di [Fase 1: Adatta lo script di formazione FSDP PyTorch](model-parallel-use-api-v2.md#model-parallel-adapt-pytorch-script-v2). Tieni presente che devi prima inizializzare PyTorch Distributed with the SMDDP backend, quindi eseguire l'inizializzazione SMP. ``` import torch.distributed as dist # Initialize with SMDDP import smdistributed.dataparallel.torch.torch_smddp dist.init_process_group(backend="smddp") # Replacing "nccl" # Initialize with SMP import torch.sagemaker as tsm tsm.init() ``` [SageMaker I Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) for PyTorch (vedi anche [Framework supportati e Regioni AWS](distributed-model-parallel-support-v2.md) di SMP v2 e della libreria SMDDP) sono [Framework e tipi di Regioni AWS istanze supportati](distributed-data-parallel-support.md) preconfezionati con il binario SMP e il binario SMDDP. Per ulteriori informazioni sulla libreria SMDDP, vedi [Esegui corsi di formazione distribuiti con la libreria di parallelismo dei dati distribuiti basata sull' SageMaker intelligenza artificiale](data-parallel.md). # Addestramento di precisione misto La libreria di parallelismo dei SageMaker modelli (SMP) v2 supporta l'addestramento di precisione misto pronto all'uso grazie all'integrazione con framework open source come FSDP e Transformer Engine. PyTorch Per ulteriori informazioni, consulta i seguenti argomenti. **Topics** + [Addestramento di precisione misto con nessuna istanza P5 utilizzando Transformer Engine FP8](#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5) + [Addestramento di precisione misto con PyTorch tipi di dati a semiprecisione utilizzando FSDP](#model-parallel-core-features-v2-mixed-precision-half-precision) ## Addestramento di precisione misto con nessuna istanza P5 utilizzando Transformer Engine FP8 [A partire dalla libreria SageMaker Model Parallelism (SMP) v2.2.0, la libreria SMP si integra con [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) e supporta l'addestramento di [precisione FP8 misto](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html) pronto all'uso, mantenendo la compatibilità con FSDP. PyTorch `MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision) Ciò significa che puoi utilizzare sia PyTorch FSDP per l'addestramento di precisione misto che Transformer Engine per l'allenamento. FP8 Per i livelli del modello non supportati dalla funzione di FP8 addestramento di Transformer Engine, tali livelli ricorrono alla PyTorch precisione mista FSDP. **Nota** SMP v2 offre FP8 supporto per i seguenti modelli Hugging Face Transformer: GPT-NeoX (disponibile in SMP v2.2.0 e versioni successive) Llama 2 (disponibile in SMP v2.2.0 e versioni successive) Mixtral 8x7b e Mixtral 8x22b (disponibili in SMP v2.5.0 e versioni successive) **Nota** Questo FP8 corso di formazione sulla funzionalità P5 è disponibile nella seguente combinazione di librerie di e libreria: SageMaker PyTorch SageMaker Python SDK v2.212.0 e versioni successive PyTorch v2.2.0 e versioni successive *FP8*(precisione in virgola mobile a 8 bit) è un tipo di dati che è emerso come un altro paradigma per accelerare l'addestramento del deep learning dei modelli LLM. Con il rilascio di NVIDIA H100 GPUs che supporta FP8 i tipi di dati, puoi sfruttare i vantaggi derivanti dai miglioramenti delle prestazioni sulle istanze P5 dotate di H100 GPUs, accelerando al contempo l'addestramento distribuito con un addestramento di precisione misto. FP8 Il tipo di FP8 dati si estende ulteriormente ai formati E4M3 ed E5M2. *E4M3* offre una maggiore precisione, dispone di una gamma dinamica limitata ed è ideale per il passaggio all’addestramento dei modelli. *E5M2* si distingue per una gamma dinamica più ampia, ma una precisione ridotta, ed è più adatto per il passaggio all’indietro, in cui la precisione è meno importante e la gamma dinamica più ampia rappresenta un vantaggio. Pertanto, ti consigliamo di utilizzare la [ricetta della FP8 strategia ibrida](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html#FP8-recipe) per sfruttare efficacemente queste caratteristiche. Per i tipi di dati a mezza precisione (FP16 e BF16), le tecniche globali di scalabilità delle perdite come la scalabilità statica delle perdite o la scalabilità dinamica delle perdite gestiscono i problemi di convergenza derivanti dalla perdita di informazioni dovuta all'arrotondamento dei gradienti a semiprecisione. Tuttavia, l'intervallo dinamico di è ancora più ristretto e le tecniche di scala globale delle perdite non sono sufficienti. FP8 A questo punto, occorre una tecnica di dimensionamento per tensore di maggiore precisione. Il *dimensionamento ritardato* è una strategia che seleziona un fattore di dimensionamento basato sui valori massimi assoluti osservati in una serie di tensori nelle iterazioni precedenti. Questa strategia presenta un compromesso: sfrutta tutti i vantaggi prestazionali del FP8 calcolo, ma richiede memoria per conservare la cronologia dei valori massimi dei tensori. Per saperne di più sulla strategia di scalabilità ritardata in generale, consulta il paper [https://arxiv.org/pdf/2209.05433.pdf](https://arxiv.org/pdf/2209.05433.pdf) Learning. In pratica, l'utilizzo FP8 è utile in tutti gli scenari di addestramento sulle istanze P5. Ti consigliamo vivamente di abilitarlo FP8 quando possibile per migliorare le prestazioni dell'allenamento. SMP v2 offre il supporto immediato di Transformer Engine. Pertanto, quando si esegue l' FP8allenamento con SMP v2 su istanze P5 di SageMaker AI (`ml.p5.48xlarge`), l'unica cosa che devi fare è importare `torch.sagemaker` lo script di addestramento e continuare a utilizzare il pacchetto Python Transformer Engine nativo. *Per ulteriori informazioni sull'uso di Transformer Engine per la FP8 formazione in generale, consulta [Using FP8 with Transformer Engine nella documentazione di NVIDIA Transformer](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html) Engine.* Il seguente frammento di codice mostra come dovrebbero apparire le righe di codice per l'importazione della libreria SMP e la configurazione nello script di training. FP8 ``` import torch.sagemaker as tsm import transformer_engine.pytorch as te from transformer_engine.common.recipe import DelayedScaling, Format # Initialize the SMP torch.sagemaker API. tsm.init() # Define a transformer model and wrap it with the torch.sagemaker.transform API. from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_config(ModelConfig) model = tsm.transform(model) # Enable E4M3 during forward pass, E5M2 during backward pass. fp8_format = Format.HYBRID # Create an FP8 recipe. fp8_recipe = DelayedScaling(fp8_format=fp8_format, amax_history_len=32, amax_compute_algo="max") # Enable FP8 autocasting. with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe, fp8_group=tsm.state.world_process_group): out = model(inp) loss = out.sum() loss.backward() ``` Per trovare un esempio pratico di FP8 formazione con SMP v2 su istanze P5, consultate il taccuino di esempio su [Accelerate SageMaker PyTorch FSDP Training of](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/llama_v2/smp-train-llama-fsdp-tp-fp8.ipynb) LLAMA-v2 (o GPT-Neox) con istanze P5. FP8 ## Addestramento di precisione misto con PyTorch tipi di dati a semiprecisione utilizzando FSDP SMP v2 supporta [PyTorch FSDP `MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision) per i lavori di formazione su istanze P4 e P5. PyTorch FSDP offre varie configurazioni per una precisione mista sia per il miglioramento delle prestazioni che per la riduzione della memoria. **Nota** Questo addestramento di precisione misto con la funzionalità PyTorch FSDP è disponibile nella seguente combinazione di librerie di e libreria. SageMaker PyTorch SMP v2.0.0 e versioni successive SageMaker Python SDK v2.200.0 e versioni successive PyTorch v2.0.1 e versioni successive La modalità standard per configurare un modello a precisione mista consiste nel creare il modello interno in `float32` e quindi consentire a FSDP di trasmettere i parametri `float16` o `bfloat16` immediatamente propagando una policy `MixedPrecision`, come mostrato nel frammento di codice riportato di seguito. *Per ulteriori informazioni sulle opzioni per modificare i parametri `dtype` for, la riduzione o i buffer per la precisione mista PyTorch, consulta l'API [PyTorch FSDP `MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision) nella documentazione. PyTorch* ``` # Native PyTorch API from torch.distributed.fsdp import MixedPrecision dtype = torch.bfloat16 mixed_precision_policy = MixedPrecision( param_dtype=dtype, reduce_dtype=dtype, buffer_dtype=dtype ) model = FSDP( model, ..., mixed_precision=mixed_precision_policy ) ``` Tieni presente che alcuni modelli (come Hugging Face Transformers Llama) prevedono buffer come `float32`. Per utilizzare `float32`, sostituisci `torch.bfloat16` con `torch.float32` nella riga che definisce l’oggetto `dtype`. # Inizializzazione ritardata dei parametri L’inizializzazione di un modello di grandi dimensioni per l’addestramento non sempre è possibile se la memoria GPU è limitata. Per risolvere un problema di memoria GPU insufficiente, puoi inizializzare il modello sulla memoria della CPU. Tuttavia, per i modelli più grandi con più di 20 o 40 miliardi di parametri, anche la memoria della CPU potrebbe risultare insufficiente. In tal caso, ti consigliamo di inizializzare il modello su quello che PyTorch chiama *metadispositivo*, che consente la creazione di tensori senza alcun dato ad essi allegato. Un tensore su un metadispositivo necessita solo delle informazioni sulla forma e questo permette di creare un modello di grandi dimensioni con i relativi parametri su metadispositivi. [Hugging Face Accelerate](https://huggingface.co/docs/accelerate/index) fornisce il gestore di contesto `init_empty_weights` che facilita la creazione di tale modello su metadispositivi mentre inizializza i buffer su un dispositivo normale. Prima dell'inizio dell'addestramento, PyTorch FSDP inizializza i parametri del modello. Questa funzionalità di inizializzazione ritardata dei parametri di SMP v2 ritarda la creazione dei parametri del modello dopo che FSDP ha eseguito la suddivisione dei parametri. PyTorch PyTorch FSDP accetta una funzione di inizializzazione dei parametri (`param_init_fn`) durante la suddivisione dei moduli e chiama ogni modulo. `param_init_fn` L’API `param_init_fn` accetta un modulo come argomento e inizializza tutti i parametri in esso contenuti, esclusi i parametri di tutti i moduli secondari. Nota che questo comportamento è *diverso dalla versione* nativa PyTorch 2.0.1, che presenta un bug che causa l'inizializzazione dei parametri più volte. SMP v2 fornisce l’API [`torch.sagemaker.delayed_param.DelayedParamIniter`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-delayed-param-init) per applicare l’inizializzazione ritardata dei parametri. I seguenti frammenti di codice mostrano come applicare l’API `torch.sagemaker.delayed_param.DelayedParamIniter` allo script di addestramento. Supponiamo di avere uno script di addestramento PyTorch FSDP come segue. ``` # Creation of model on meta device from accelerate import init_empty_weights with init_empty_weights(): model = create_model() # Define a param init fn, below is an example for Hugging Face GPTNeoX. def init_weights(module): d = torch.cuda.current_device() # Note that below doesn't work if you have buffers in the model # buffers will need to reinitialized after this call module.to_empty(device=d, recurse=False) if isinstance(module, (nn.Linear, Conv1D)): module.weight.data.normal_(mean=0.0, std=args.initializer_range) if module.bias: module.bias.data.zero_() elif isinstance(module, nn.Embedding): module.weight.data.normal_(mean=0.0, std=args.initializer_range) if module.padding_idx: module.weight.data[module.padding_idx].zero_() elif isinstance(module, nn.LayerNorm): module.bias.data.zero_() module.weight.data.fill_(1.0) # Changes to FSDP wrapper. model = FSDP( model, ..., param_init_fn=init_weights ) # At this point model is initialized and sharded for sharded data parallelism. ``` Tieni presente che l’approccio di inizializzazione ritardata dei parametri non è indipendente dal modello. Per risolvere questo problema, è necessario scrivere una funzione `init_weights`, come illustrato nell’esempio precedente, in modo che corrisponda all’inizializzazione nella definizione originale del modello e che ne includa tutti i parametri. Per semplificare il processo di preparazione della funzione `init_weights`, SMP v2 implementa questa funzione di inizializzazione per i seguenti modelli: GPT-2, GPT-J, GPT-NeoX e Llama di Hugging Face Transformers. L’API `torch.sagemaker.delayed_param.DelayedParamIniter` funziona anche con l’implementazione parallela del tensore SMP, modello `torch.sagemaker.tensor_parallel.transformer.TransformerLMHead`, che può essere chiamato dopo chiamata API [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform). Utilizzando l'`torch.sagemaker.delayed_param.DelayedParamIniter`API, è possibile adattare lo script PyTorch FSDP come segue. Dopo aver creato un modello con pesi vuoti, registra l’API `torch.sagemaker.delayed_param.DelayedParamIniter` sul modello e definiscine un oggetto. Passa l'oggetto alla classe `param_init_fn` PyTorch FSDP. ``` from torch.sagemaker.delayed_param import DelayedParamIniter from accelerate import init_empty_weights with init_empty_weights(): model = create_model() delayed_initer = DelayedParamIniter(model) with delayed_initer.validate_params_and_buffers_inited(): model = FSDP( model, ..., param_init_fn=delayed_initer.get_param_init_fn() ) ``` **Note sui pesi condivisi** Quando si allenano modelli con pesi uguali, è necessario prestare particolare attenzione a legare i pesi dopo aver inizializzato i pesi con l'inizializzazione ritardata dei parametri. PyTorch FSDP non dispone di un meccanismo per legare i pesi dopo averli inizializzati utilizzando quanto sopra. `param_init_fn` Per risolvere questi casi, abbiamo aggiunto un’API per consentire a `post_init_hook_fn`, da utilizzare per condividere i pesi. È possibile inserire qualsiasi funzione che accetti il modulo come argomento, ma è presente anche una definizione predefinita `post_param_init_fn` definita in `DelayedParamIniter` che chiama il metodo `tie_weights` del modulo, se esistente. Tieni presente che è sempre sicuro passare in `post_param_init_fn` anche se non esiste un metodo `tie_weights` per il modulo. ``` with delayed_initer.validate_params_and_buffers_inited(): model = FSDP( model, ..., param_init_fn=delayed_initer.get_param_init_fn(), post_param_init_fn=delayed_initer.get_post_param_init_fn() ) ``` # Checkpoint di attivazione Il *checkpoint di attivazione* è una tecnica per ridurre l’utilizzo della memoria cancellando le attivazioni di determinati livelli e ricalcolandole durante un passaggio all’indietro. In effetti, ciò consente di rinunciare a tempi di calcolo aggiuntivi per ridurre l’utilizzo della memoria. Se un modulo è sottoposto a checkpoint, alla fine di un passaggio in avanti, rimangono in memoria solo gli input iniziali al modulo e le uscite finali del modulo. PyTorch rilascia tutti i tensori intermedi che fanno parte del calcolo all'interno di quel modulo durante il passaggio in avanti. Durante il passaggio all'indietro dei moduli checkpoint, ricalcola questi tensori. PyTorch A questo punto, i livelli oltre questo modulo di checkpoint hanno terminato il passaggio all’indietro, quindi il picco di utilizzo della memoria con il checkpoint diminuisce. SMP v2 supporta il modulo di checkpoint di attivazione,. PyTorch [https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing](https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing) Di seguito sono riportati alcuni esempi di checkpoint di attivazione del modello di Hugging Face GPT-NeoX. **Checkpoint dei livelli di trasformatore del modello di Hugging Face GPT-NeoX** ``` from transformers.models.gpt_neox import GPTNeoXLayer from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import ( apply_activation_checkpointing ) # check_fn receives a module as the arg, # and it needs to return whether the module is to be checkpointed def is_transformer_layer(module): from transformers.models.gpt_neox import GPTNeoXLayer return isinstance(submodule, GPTNeoXLayer) apply_activation_checkpointing(model, check_fn=is_transformer_layer) ``` **Checkpoint di qualsiasi altro livello di trasformatore del modello di Hugging Face GPT-NeoX** ``` # check_fn receives a module as arg, # and it needs to return whether the module is to be checkpointed # here we define that function based on global variable (transformer_layers) from transformers.models.gpt_neox import GPTNeoXLayer from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import ( apply_activation_checkpointing ) transformer_layers = [ m for m model.modules() if isinstance(m, GPTNeoXLayer) ] def is_odd_transformer_layer(module): return transformer_layers.index(module) % 2 == 0 apply_activation_checkpointing(model, check_fn=is_odd_transformer_layer) ``` In alternativa, ha PyTorch anche il `torch.utils.checkpoint` modulo per il checkpointing, che viene utilizzato da un sottoinsieme di modelli Hugging Face Transformers. Questo modulo funziona anche con SMP v2. Tuttavia, l’aggiunta del wrapper di checkpoint richiede l’accesso alla definizione del modello. Ti consigliamo, quindi, di utilizzare il metodo `apply_activation_checkpointing`. # Offload di attivazione **Importante** In SMP v2.2.0, la funzionalità di offload di attivazione della libreria SMP non funziona. Utilizzate invece l'offload di attivazione nativo. PyTorch In genere, il passaggio in avanti calcola le attivazioni su ogni livello e le conserva nella memoria della GPU fino al termine del passaggio all’indietro per il livello corrispondente. Lo scaricamento di questi tensori sulla memoria della CPU dopo il passaggio in avanti e il loro recupero sulla GPU quando sono necessari può far risparmiare un notevole utilizzo della memoria della GPU. PyTorch supporta l'offload delle attivazioni, ma l'implementazione rimane inattiva mentre le attivazioni vengono GPUs recuperate dalla CPU durante il passaggio all'indietro. Questo causa un notevole peggioramento delle prestazioni quando si utilizza l’offload di attivazione. SMP v2 è in grado di migliorare questo offload di attivazione. Recupera le attivazioni in anticipo, prima che siano necessarie, affinché la GPU possa iniziare a passarle all’indietro. La funzione di pre-fetching consente di eseguire i progressi dell'allenamento in modo più efficiente senza inattività. GPUs Questo consente di usufruire dei vantaggi derivanti da un minore utilizzo della memoria senza peggioramento delle prestazioni. È possibile mantenere i PyTorch moduli nativi per l'offload delle attivazioni nello script di formazione. Di seguito è riportato un esempio di struttura di applicazione della funzionalità di offload dell’attivazione SMP nello script. Tieni presente che l’offload di attivazione è applicabile *solo* se utilizzato insieme a [Checkpoint di attivazione](model-parallel-core-features-v2-pytorch-activation-checkpointing.md). Per saperne di più sugli strumenti nativi di PyTorch checkpoint per l'offload delle attivazioni, consulta: + [https://github.com/pytorch/pytorch/blob/v2.0.1/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py#L171](https://github.com/pytorch/pytorch/blob/v2.0.1/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py#L171) + [Activation Checkpointing](https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing) nel PyTorch blog *Scaling Multi-modal Foundation Models* in with Distributed. TorchMultimodal PyTorch [È possibile applicare la funzionalità di offload dell'attivazione SMP al checkpoint di attivazione. PyTorch ](https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing) A tale scopo, è sufficiente aggiungere i parametri `sm_activation_offloading` e `activation_loading_horizon` al dizionario di configurazione di SMP durante [Fase 2: avvio di un job di addestramento](model-parallel-use-api-v2.md#model-parallel-launch-a-training-job-v2). I seguenti frammenti di codice mostrano come aggiungere il modulo di inizializzazione SMP `torch.sagemaker.init()` allo script di addestramento e impostare il dizionario di configurazione di SMP in formato JSON per il programma di avvio del job di addestramento seguendo il processo in due fasi introdotto in [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). [Non è necessario apportare modifiche al PyTorch modello o alla configurazione FSDP. PyTorch ](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp) Per ulteriori informazioni sui parametri `sm_activation_offloading` e `activation_loading_horizon`, vedi [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **Configurazione di SMP** ``` { "activation_loading_horizon": 2, "sm_activation_offloading": True } ``` **Nello script di addestramento** **Nota** Durante l'attivazione della funzione di offload dell'attivazione SMP, assicuratevi di utilizzare anche la PyTorch `offload_wrapper` funzione e di applicarla al modulo root. La funzionalità di offload dell’attivazione SMP utilizza il modulo root per determinare quando eseguire il passaggio all’indietro per avviare il recupero anticipato. ``` import torch.sagemaker as tsm tsm.init() # Native PyTorch module for activation offloading from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import ( apply_activation_checkpointing, offload_wrapper, ) model = FSDP(...) # Activation offloading requires activation checkpointing. apply_activation_checkpointing( model, check_fn=checkpoint_transformer_layers_policy, ) model = offload_wrapper(model) ``` # Parallelizzazione tensoriale La *parallelizzazione tensoriale* è un tipo di parallelizzazione del modello in cui pesi, gradienti e stati dell’ottimizzatore specifici del modello vengono suddivisi tra i dispositivi. A differenza della parallelizzazione delle pipeline, che mantiene intatti i singoli pesi ma partiziona il *set* di pesi, gradienti o l’ottimizzatore tra i dispositivi, la parallelizzazione tensoriale esegue lo sharding dei pesi *individuali*. Ciò comporta in genere il calcolo distribuito di operazioni, moduli o livelli specifici del modello. Il parallelismo tensoriale è necessario nei casi in cui un singolo parametro consuma la maggior parte della memoria della GPU (ad esempio tabelle di incorporamento di grandi dimensioni con un vocabolario di grandi dimensioni un livello softmax di grandi dimensioni con un numero elevato di classi). In questo caso, trattare questo tensore o operazione di grandi dimensioni come un’unità atomica è inefficiente e impedisce l’equilibrio del carico di memoria. SMP v2 si integra con [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) per l'implementazione del parallelismo tensoriale e funziona su FSDP. PyTorch APIs È possibile abilitare contemporaneamente il parallelismo PyTorch tensoriale FSDP e SMP e determinare il miglior parallelismo del modello per le migliori prestazioni. In pratica, la parallelizzazione tensoriale è particolarmente utile nei seguenti scenari: + In caso di addestramento con contesti di notevole lunghezza, poiché questo conduce a un’elevata memoria di attivazione con il solo FSDP. + In caso di addestramento con cluster molto grandi, in cui la dimensione globale del batch supera i limiti desiderati. ## Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP SMP v2 offre attualmente il supporto per la parallelizzazione tensoriale per i seguenti modelli di Hugging Face Transformers. + GPT-NeoX + Llama 2 + Llama 3 + [Mistral 7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) + [Mixtral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) + [Mixtral 8x22B](https://huggingface.co/mistralai/Mixtral-8x22B-v0.1) Per la configurazione di riferimento relativa all’applicazione della parallelizzazione tensoriale su questi modelli, vedi [Consigli per la configurazione](model-parallel-best-practices-v2.md#model-parallel-best-practices-v2-config-tips). ## Configurazione della parallelizzazione tensoriale Per `tensor_parallel_degree`, seleziona un valore per il grado di parallelizzazione tensoriale. Il valore deve dividere equamente il numero di nel cluster. GPUs Ad esempio, per suddividere il modello utilizzando un'istanza con 8 GPUs, scegliete 2, 4 o 8. È consigliabile iniziare con un numero piccolo e aumentarlo gradualmente fino a quando il modello risulta adatto alla memoria della GPU. I seguenti frammenti di codice mostrano come aggiungere il modulo di inizializzazione SMP `torch.sagemaker.init()` allo script di addestramento e impostare il dizionario di configurazione di SMP in formato JSON per il programma di avvio del job di addestramento seguendo il processo in due fasi introdotto in [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). Non è necessario apportare modifiche al PyTorch modello o alla configurazione [PyTorch FSDP](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp). Per ulteriori informazioni sui parametri `tensor_parallel_degree` e `random_seed`, vedi [Parametri di configurazione delle funzionalità principali di SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **Configurazione di SMP** ``` { "tensor_parallel_degree": 8, "random_seed": 0 } ``` **Nello script di addestramento** Esegui l’inizializzazione con `torch.sagemaker.init()` per attivare SMP v2 ed eseguire il wrapping del modello con l’API [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform). ``` import torch.sagemaker as tsm tsm.init() from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_config(..) model = tsm.transform(model) ``` ## Salvataggio e caricamento dei checkpoint Hugging Face Transformers Dopo aver trasformato un modello, la libreria SMP ne modifica il dizionario di stato (`state_dict`). Ciò significa che il modello diventa incompatibile con le funzionalità di checkpoint originali di Hugging Face Transformers. Per gestire ciò, la libreria SMP consente di APIs salvare i checkpoint da un modello trasformato nella rappresentazione Hugging Face Transformer `torch.sagemaker.transform` e l'API di caricare un checkpoint del modello Hugging Face Transformer per la messa a punto. Per ulteriori informazioni sul salvataggio dei checkpoint durante l’utilizzo della funzionalità di parallelizzazione tensoriale di SMP v2, vedi [Checkpointing con SMP](model-parallel-core-features-v2-checkpoints.md). Per ulteriori informazioni sull’esecuzione del fine-tuning di un modello che applica la funzionalità di parallelizzazione tensoriale di SMP v2, vedi [Fine-tuning](model-parallel-core-features-v2-fine-tuning.md). # Fine-tuning Il fine-tuning è un processo di addestramento continuo di modelli preaddestrati per migliorare le prestazioni in casi d’uso specifici. La messa a punto di piccoli modelli che si adattano completamente a una singola GPU o quelli che contengono 8 copie del modello è semplice. CPUs Non richiede infatti particolari modifiche al normale addestramento FSDP. Per quanto riguarda i modelli più grandi di questo, è necessario prendere in considerazione l’utilizzo della funzionalità di inizializzazione ritardata dei parametri, che può risultare complicata. Per risolvere questo problema, la libreria SMP carica il modello completo su una delle classificazioni, mentre le altre creano modelli con pesi vuoti su un metadispositivo. Quindi, PyTorch FSDP inizializza i pesi sui ranghi diversi da zero utilizzando la `init_weights` funzione e sincronizza i pesi su tutti i ranghi con i pesi di grado 0 con impostato su. `sync_module_states` `True` Il frammento di codice riportato di seguito mostra come eseguire la configurazione nello script di addestramento. ``` import torch.distributed as dist from transformers import AutoModelForCasalLM from accelerate import init_empty_weights from torch.sagemaker.delayed_param import DelayedParamIniter if dist.get_rank() == 0: model = AutoModelForCasalLM.from_pretrained(..., low_cpu_mem_usage=True) else: with init_empty_weights(): model = AutoModelForCasalLM.from_config(AutoConfig.from_pretrained(...)) delayed_initer = DelayedParamIniter(model) model = FSDP( model, ..., sync_module_states=True, param_init_fn=delayed_initer.get_param_init_fn() if dist.get_rank() > 0 else None ) ``` ## Fine-tuning di un modello di Hugging Face Transformer preaddestrato con parallelizzazione tensoriale SMP Questa sezione illustra il caricamento dei modelli di trasformatore per due casi d’uso, ovvero il fine-tuning di modelli Transformer di piccole e di grandi dimensioni. Per i modelli più piccoli senza ritardi nell'inizializzazione dei parametri, avvolgete il modello con l'API prima di avvolgerlo con FSDP. `torch.sagemaker.transform` PyTorch ``` import functools from transformers import AutoModelForCausalLM from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy from torch.sagemaker import transform model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", low_cpu_mem_usage=True) # Transform model while loading state dictionary from rank 0. tp_model = transform(model, load_state_dict_from_rank0=True) # Wrap with FSDP. model = FSDP( tp_model, ... sync_module_states=True, ) ``` Per i modelli più grandi, l’approccio precedente provoca l’esaurimento della memoria della CPU. Per evitare problemi con la memoria della CPU, è consigliabile utilizzare l’inizializzazione ritardata dei parametri. In questo caso, puoi applicare l’API `torch.sagemaker.transform` e l’API `torch.sagemaker.delayed_param.DelayedParamIniter` come mostrato nel seguente esempio di codice. ``` from transformers import AutoModelForCausalLM from torch.sagemaker import transform from torch.sagemaker.delayed_param import DelayedParamIniter # Create one instance of model without delayed param # on CPU, on one rank. if dist.get_rank() == 0: model = AutoModelForCasalLM.from_pretrained(...,low_cpu_mem_usage=True) else: with init_empty_weights(): model = AutoModelForCasalLM.from_config(AutoConfig.from_pretrained(...)) # Transform model while loading state dictionary from rank 0 model = transform(model, load_state_dict_from_rank0=True) if dist.get_rank() != 0: # For fine-tuning, delayed parameter on non-zero ranks delayed_initer = DelayedParamIniter(model) else: delayed_initer = None with ( delayed_initer.validate_params_and_buffers_inited() if delayed_initer else nullcontext() ): # Wrap the model with FSDP model = FSDP( model, ..., sync_module_states=True, param_init_fn=delayed_initer.get_param_init_fn() if delayed_initer else None ) ``` # FlashAttention SMP v2 supporta i [FlashAttention](https://github.com/HazyResearch/flash-attention)kernel e ne semplifica l'applicazione a vari scenari per i modelli Hugging Face Transformer. Nota che se utilizzi il FlashAttention pacchetto v2.0 o successivo, SMP utilizza la FlashAttention v2; tuttavia, Triton flash attention utilizza per impostazione predefinita il kernel flash attention nella v1.x, rendendolo supportato esclusivamente nella v1. FlashAttention FlashAttention Il modulo (`nn.Module`) è un’API di basso livello che definisce i livelli di attenzione di un modello. Dovrebbe essere applicato subito dopo la creazione del modello, ad esempio dall’API `AutoModelForCausalLM.from_config()`, e prima che si esegua la trasformazione o il wrapping del modello con FSDP. ## Usa i kernel per l'attenzione personale FlashAttention Il frammento di codice riportato di seguito mostra come utilizzare l’API [`torch.sagemaker.nn.attn.FlashSelfAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-flashselfattention) fornita da SMP v2. ``` def new_attn(self, q, k, v, attention_mask=None, head_mask=None): return ( self.flashmod((q, k, v), causal=True, cast_dtype=torch.bfloat16, layout="b h s d"), None, ) for layer in model.gpt_neox.layers: layer.attention.flash_mod = torch.sagemaker.nn.attn.FlashSelfAttention() layer.attention._attn = functools.partial(new_attn, layer.attention) ``` ## Usa i FlashAttention kernel per attirare l'attenzione sulle query raggruppate SMP v2 supporta anche i [FlashAttention](https://github.com/HazyResearch/flash-attention)kernel for grouped-query attention (GQA) e ne semplifica l'applicazione a vari scenari per i modelli Hugging Face Transformer. A differenza dell’architettura di attenzione originale, GQA suddivide equamente le teste di query in gruppi e le teste di query dello stesso gruppo condividono le stesse teste di chiavi e valori. Pertanto, le teste q e kv vengono passate alla chiamata in avanti separatamente. Nota: il numero di teste q deve essere divisibile per il numero di teste kv. **Esempio di utilizzo FlashGroupedQueryAttention** Il frammento di codice riportato di seguito mostra come utilizzare l’API [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) fornita da SMP v2. ``` from transformers.models.llama.modeling_llama import LlamaAttention from torch.sagemaker.nn.attn import FlashGroupedQueryAttention class LlamaFlashAttention(LlamaAttention): def __init__(self, config: LlamaConfig): super().__init__(config) self.flash_attn = FlashGroupedQueryAttention( attention_dropout_prob=0.0, ) def forward( self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, ... ): query_states = self.q_proj(hidden_states) key_states = self.k_proj(hidden_states) value_states = self.v_proj(hidden_states) ... kv = (key_states, value_states) attn_output = self.flash_attn( query_states, kv, attn_mask=attention_mask, causal=True, layout="b h s d", ) ... attn_output = self.o_proj(attn_output) ... return attn_output ``` La libreria SMP fornisce anche [`torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn), che utilizza l’API [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) a basso livello. A partire dalla v4.36.0., Hugging Face Transformers dispone di un’implementazione simile chiamata [https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py). Il frammento di codice riportato di seguito mostra come utilizzare l’API `LlamaFlashAttention` SMP v2 o l’API `LlamaFlashAttention2` Transformers per sostituire i livelli di attenzione di un modello Llama esistente. ``` from torch.sagemaker.nn.huggingface.llama_flashattn import LlamaFlashAttention from transformers.models.llama.modeling_llama import LlamaFlashAttention2 flash_attn_class = LlamaFlashAttention # or flash_attn_class = LlamaFlashAttention2 attn_name = "self_attn" for layer in model.model.layers: prev_layer = getattr(layer, attn_name) setattr(layer, attn_name, flash_attn_class(model.config)) ``` # Checkpointing con SMP La libreria SageMaker Model Parallelism (SMP) supporta i checkpoint e fornisce APIs questo supporto PyTorch APIs per il corretto funzionamento del checkpoint durante l'utilizzo della libreria SMP. PyTorch FSDP (Fully Sharded Data Parallelism) supporta tre tipi di checkpoint: completi, frammentati e locali, ognuno dei quali serve a scopi diversi. I checkpoint completi vengono utilizzati quando si esporta il modello dopo il completamento dell’addestramento, poiché la generazione di un checkpoint completo è un processo impegnativo dal punto di vista del calcolo. I checkpoint suddivisi aiutano a salvare e caricare lo stato di un modello con sharding per ogni singola classificazione. Con i checkpoint condivisi, puoi riprendere l'allenamento con diverse configurazioni hardware, ad esempio un numero diverso di. GPUs Tuttavia, il caricamento di checkpoint sottoposti a sharding può essere lento, poiché la comunicazione coinvolge più dispositivi. La libreria SMP fornisce funzionalità di checkpoint locali, che permettono un recupero più rapido dello stato del modello senza l’ulteriore sovraccarico delle comunicazioni. Tieni presente che i checkpoint creati da FSDP richiedono la scrittura su un file system di rete condiviso come Amazon. FSx ## Checkpoint locali asincroni Durante l’addestramento dei modelli di machine learning, non è necessario attendere che i file di checkpoint vengano salvati su disco nelle iterazioni successive. Con il rilascio di SMP v2.5, la libreria supporta il salvataggio asincrono dei file di checkpoint. Ciò significa che la successiva iterazione dell'addestramento può essere eseguita contemporaneamente alle operazioni di input e output (). I/O) operations for creating checkpoints, without being slowed down or held back by those I/O Inoltre, il processo di recupero dei parametri del modello frammentato e dell'ottimizzatore PyTorch può richiedere molto tempo a causa della comunicazione collettiva aggiuntiva necessaria per lo scambio di metadati tensoriali distribuiti tra i ranghi. Anche quando viene utilizzato `StateDictType.LOCAL_STATE_DICT` per salvare i checkpoint locali per ogni rango, richiama comunque gli hook che eseguono comunicazioni collettive. PyTorch Per attenuare questo problema e ridurre il tempo necessario per il recupero dei checkpoint, SMP introduce `SMStateDictType.SM_LOCAL_STATE_DICT`, che consente un recupero più rapido dei checkpoint dell’ottimizzatore e del modello evitando il sovraccarico causato dalla comunicazione collettiva. **Nota** Mantenere la coerenza nel `SHARD_DEGREE` FSDP è un requisito per l’utilizzo di `SMStateDictType.SM_LOCAL_STATE_DICT`. Assicurati che `SHARD_DEGREE` rimanga invariato. Sebbene il numero di repliche del modello possa variare, quando si riprende da un checkpoint il grado di sharding del modello deve essere identico alla configurazione di addestramento precedente. ``` import os import torch.distributed as dist import torch.sagemaker as tsm from torch.sagemaker import state from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.sagemaker.distributed.checkpoint.state_dict_saver import ( async_save, maybe_finalize_async_calls, ) from torch.sagemaker.distributed.checkpoint.state_dict_utils import ( sm_state_dict_type, SMStateDictType, ) global_rank = dist.get_rank() save_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}_fsdp{model.rank}" # 1. Get replication ranks and group current_replication_group = None current_replication_ranks = None for replication_ranks in state.ranker.get_rep_groups(): rep_group = dist.new_group(replication_ranks) if global_rank in replication_ranks: current_replication_group = rep_group current_replication_ranks = replication_ranks coordinator_rank = min(current_replication_ranks) # 2. Wait for the previous checkpointing done maybe_finalize_async_calls( blocking=True, process_group=current_replication_group ) # 3. Get model local checkpoint with sm_state_dict_type(model, SMStateDictType.SM_LOCAL_STATE_DICT): state_dict = { "model": model.state_dict(), "optimizer": optimizer.state_dict(), # Potentially add more customized state dicts. } # 4. Save a local checkpoint async_save( state_dict, checkpoint_id=os.path.join(save_dir, sub_dir), process_group=current_replication_group, coordinator_rank=coordinator_rank, ) ``` Il frammento di codice riportato di seguito mostra come caricare un checkpoint utilizzando `SMStateDictType.SM_LOCAL_STATE_DICT`. ``` import os import torch.sagemaker as tsm from torch.sagemaker import state from torch.sagemaker.distributed.checkpoint.state_dict_loader import load from torch.sagemaker.distributed.checkpoint.state_dict_utils import ( sm_state_dict_type, SMStateDictType, init_optim_state ) from torch.sagemaker.distributed.checkpoint.filesystem import ( DistributedFileSystemReader, ) load_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}_fsdp{model.rank}" global_rank = dist.get_rank() checkpoint_id = os.path.join(load_dir, sub_dir) storage_reader = DistributedFileSystemReader(checkpoint_id) # 1. Get replication ranks and group current_replication_group = None current_replication_ranks = None for replication_ranks in state.ranker.get_rep_groups(): rep_group = dist.new_group(replication_ranks) if global_rank in replication_ranks: current_replication_group = rep_group current_replication_ranks = replication_ranks coordinator_rank = min(current_replication_ranks) # 2. Create local state_dict with sm_state_dict_type(model, SMStateDictType.SM_LOCAL_STATE_DICT): state_dict = { "model": model.state_dict(), # Potentially add more customized state dicts. } # Init optimizer state_dict states by setting zero grads and step. init_optim_state(optimizer, skip_empty_param=True) state_dict["optimizer"] = optimizer.state_dict() # 3. Load a checkpoint load( state_dict=state_dict, process_group=current_replication_group, coordinator_rank=coordinator_rank, storage_reader=storage_reader, ) ``` La memorizzazione di checkpoint per modelli linguistici di grandi dimensioni (LLMs) può essere costosa in quanto spesso richiede la creazione di un grande volume di file system. Per ridurre i costi, hai la possibilità di salvare i checkpoint direttamente su Amazon S3 senza la necessità di servizi di file system aggiuntivi come Amazon. FSx Per salvare i checkpoint in S3 specificando un URL S3 come destinazione puoi applicare l’esempio precedente al frammento di codice riportato di seguito. ``` key = os.path.join(checkpoint_dir, sub_dir) checkpoint_id= f"s3://{your_s3_bucket}/{key}" async_save(state_dict, checkpoint_id=checkpoint_id, **kw) load(state_dict, checkpoint_id=checkpoint_id, **kw) ``` ## Checkpoint sottoposti a sharding eseguiti in modo asincrono Potrebbero verificarsi situazioni in cui è necessario continuare la formazione con diverse configurazioni hardware, ad esempio modificando il numero di. GPUs In questi casi, i job di addestramento devono caricare i checkpoint durante il resharding e riprendere l’addestramento successivo con un numero diverso di `SHARD_DEGREE`. Per risolvere lo scenario in cui è necessario riprendere l’addestramento con un numero diverso di `SHARD_DEGREE`, è necessario salvare i checkpoint del modello utilizzando il tipo di dizionario di stato sottoposto a sharding, rappresentato da `StateDictType.SHARDED_STATE_DICT`. Il salvataggio dei checkpoint in questo formato consente di gestire correttamente il processo di resharding quando si continua l’addestramento con una configurazione hardware modificata. Il frammento di codice fornito illustra come utilizzare l’API `tsm` per salvare in modo asincrono i checkpoint sottoposti a sharding, rendendo il processo di addestramento più semplice ed efficiente. ``` import os import torch.sagemaker as tsm from torch.sagemaker import state from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp import StateDictType from torch.sagemaker.utils.process_group_utils import get_global_ranks from torch.sagemaker.distributed.checkpoint.state_dict_saver import ( async_save, maybe_finalize_async_calls, ) save_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}" checkpoint_id = os.path.join(save_dir, sub_dir) # To determine whether curreto take part in checkpointing. global_rank = dist.get_rank() action_rank = state.ranker.get_rep_rank(global_rank) == 0 process_group = model.process_group coordinator_rank = min(get_global_ranks(process_group)) # 1. wait for the previous checkpointing done maybe_finalize_async_calls(blocking=True, process_group=process_group) # 2. retrieve model & optimizer sharded state_dict with FSDP.state_dict_type(model, StateDictType.SHARDED_STATE_DICT): state_dict = { "model": model.state_dict(), "optimizer": FSDP.optim_state_dict(model, optimizer), # Potentially add more customized state dicts. } # 3. save checkpoints asynchronously using async_save if action_rank: async_save( state_dict, checkpoint_id=checkpoint_id, process_group=process_group, coordinator_rank=coordinator_rank, ) ``` Il processo di caricamento dei checkpoint sottoposti a sharding è simile a quello della sezione precedente, ma prevede l’utilizzo di `torch.sagemaker.distributed.checkpoint.filesystem.DistributedFileSystemReader` e del relativo metodo `load`. Il metodo `load` di questa classe consente di caricare i dati dei checkpoint sottoposti a sharding, seguendo un processo analogo a quello descritto in precedenza. ``` import os from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp import StateDictType from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict from torch.sagemaker.distributed.checkpoint.state_dict_loader import load from torch.sagemaker.utils.process_group_utils import get_global_ranks from torch.sagemaker.distributed.checkpoint.filesystem import ( DistributedFileSystemReader, ) load_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}" checkpoint_id = os.path.join(load_dir, sub_dir) reader = DistributedFileSystemReader(checkpoint_id) process_group = model.process_group coordinator_rank = min(get_global_ranks(process_group)) with FSDP.state_dict_type(model, StateDictType.SHARDED_STATE_DICT): # 1. Load model and everything else except the optimizer. state_dict = { "model": model.state_dict() # Potentially more customized state dicts. } load( state_dict, storage_reader=reader, process_group=process_group, coordinator_rank=coordinator_rank, ) model.load_state_dict(state_dict["model"]) # 2. Load optimizer. optim_state = load_sharded_optimizer_state_dict( model_state_dict=state_dict["model"], optimizer_key="optimizer", storage_reader=reader, process_group=process_group, ) flattened_optimizer_state = FSDP.optim_state_dict_to_load( optim_state["optimizer"], model, optimizer, group=model.process_group ) optimizer.load_state_dict(flattened_optimizer_state) ``` ## Checkpoint del modello completi Al termine dell’addestramento, è possibile salvare un checkpoint completo che combini tutti gli shard di un modello in un unico file di checkpoint. La libreria SMP supporta completamente l'API dei checkpoint del modello PyTorch completo, quindi non è necessario apportare alcuna modifica. Tieni presente che se utilizzi [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md) SMP, la libreria SMP trasforma il modello. In questo caso, quando si esegue il checkpoint del modello completo, la libreria SMP traduce il modello nel formato di checkpoint Hugging Face Transformers per impostazione predefinita. Nei casi in cui ci si allena con il parallelismo del tensore SMP e si disattiva il processo di traduzione SMP, è possibile utilizzare l'`translate_on_save`argomento dell' PyTorch `FullStateDictConfig`API per attivare o disattivare la traduzione automatica SMP in base alle esigenze. Ad esempio, se ti stai concentrando sull’addestramento di un modello, non è necessario aggiungere il processo di traduzione che comporta sovraccarichi aggiuntivi. In questo caso, è consigliabile scegliere l’impostazione `translate_on_save=False`. Inoltre, se prevedi di continuare a utilizzare la traduzione SMP del modello per ulteriori cicli di addestramento futuri, puoi disattivarla e salvare la traduzione SMP del modello per un uso successivo. La traduzione del modello nel formato di checkpoint del modello di Hugging Face Transformers è necessaria quando si conclude l’addestramento del modello e lo si utilizza per l’inferenza. ``` from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp import FullStateDictConfig import torch.sagemaker as tsm # Save checkpoints. with FSDP.state_dict_type( model, StateDictType.FULL_STATE_DICT, FullStateDictConfig( rank0_only=True, offload_to_cpu=True, # Default value is to translate back to Hugging Face Transformers format, # when saving full checkpoints for models trained with SMP tensor parallelism. # translate_on_save=True ), ): state_dict = model.state_dict() if dist.get_rank() == 0: logger.info("Processed state dict to save. Starting write to disk now.") os.makedirs(save_dir, exist_ok=True) # This name is needed for HF from_pretrained API to work. torch.save(state_dict, os.path.join(save_dir, "pytorch_model.bin")) hf_model_config.save_pretrained(save_dir) dist.barrier() ``` Tieni presente che l’opzione `FullStateDictConfig(rank0_only=True, offload_to_cpu=True)` consiste nel riunire il modello sulla CPU del dispositivo con classificazione 0 per risparmiare memoria durante l’addestramento di modelli di grandi dimensioni. Per caricare il modello per l’inferenza, puoi eseguire questa operazione come illustrato nell’esempio di codice riportato di seguito. Tieni presente che la classe `AutoModelForCausalLM` potrebbe cambiare passando ad altre classi del generatore di fattori in Hugging Face Transformers, ad esempio`AutoModelForSeq2SeqLM`, a seconda del modello. Per ulteriori informazioni, consulta la [documentazione di Hugging Face Transformers](https://huggingface.co/docs/transformers/v4.36.1/en/model_doc/auto#natural-language-processing). ``` from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained(save_dir) ``` # Esempi di Amazon SageMaker AI Model Parallelism Library v2 Questa pagina fornisce un elenco di blog e notebook Jupyter che presentano esempi pratici di implementazione della libreria SageMaker Model Parallelism (SMP) v2 per eseguire lavori di formazione distribuiti sull'intelligenza artificiale. SageMaker ## Blog e casi di studio I seguenti blog illustrano casi di studio relativi all’utilizzo di SMP v2. + [La libreria parallela di modelli Amazon SageMaker AI ora accelera i carichi di lavoro PyTorch FSDP fino al 20%](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-model-parallel-library-now-accelerates-pytorch-fsdp-workloads-by-up-to-20/) ## PyTorch taccuini di esempio [I taccuini di esempio sono disponibili nell'archivio degli esempi AI. SageMaker GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/training/distributed_training/) Per scaricare gli esempi, esegui il comando seguente per clonare il repository e accedere a `training/distributed_training/pytorch/model_parallel_v2`. **Nota** Clona ed esegui i notebook di esempio nel seguente AI ML. SageMaker IDEs [SageMaker JupyterLab](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-jl.html)(disponibile in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creato dopo dicembre 2023) [SageMaker Code Editor](https://docs.aws.amazon.com/sagemaker/latest/dg/code-editor.html) (disponibile in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creato dopo dicembre 2023) [Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) (disponibile come applicazione in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creata dopo dicembre 2023) [SageMaker Istanze Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) ``` git clone https://github.com/aws/amazon-sagemaker-examples.git cd amazon-sagemaker-examples/training/distributed_training/pytorch/model_parallel_v2 ``` **Notebook di esempio SMP v2** + [Accelera l'addestramento di Llama v2 con SMP v2, PyTorch FSDP e Transformer Engine eseguendo la formazione su istanze P5 FP8 ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/llama_v2/smp-train-llama-fsdp-tp-fp8.ipynb) + [Ottimizza Llama v2 con SMP v2 e FSDP su larga scala utilizzando il parallelismo tensoriale, lo sharding ibrido e l'offload di attivazione PyTorch ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/llama_v2/smp-finetuning-llama-fsdp-tp.ipynb) + [Addestra GPT-Neox con SMP v2 PyTorch e FSDP su larga scala](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/gpt-neox/smp-train-gpt-neox-fsdp-tp.ipynb) + [Ottimizza GPT-Neox con SMP v2 e FSDP su larga scala utilizzando il parallelismo tensoriale, lo sharding ibrido e l'offload di attivazione PyTorch ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/gpt-neox/smp-finetuning-gpt-neox-fsdp-tp.ipynb) # SageMaker best practice per il parallelismo dei modelli distribuiti Utilizza le seguenti linee guida quando esegui un processo di formazione distribuito con la SageMaker model parallel library v2 (SMP v2). ## Configurazione della configurazione corretta per la formazione distribuita Per stimare e individuare il miglior punto di partenza per applicare le tecniche di addestramento distribuito fornite da SMP v2, consulta l’elenco riportato di seguito. Ogni voce dell’elenco illustra i vantaggi e i potenziali compromessi legati all’utilizzo di [Caratteristiche principali della libreria di parallelismo dei SageMaker modelli v2](model-parallel-core-features-v2.md). ### Consigli per la configurazione In questa sezione vengono fornite linee guida su come stabilire le migliori configurazioni di modello ottenere per un throughput ottimale con requisiti globali relativi alle dimensioni dei batch. Innanzitutto, indipendentemente dalle dimensioni del modello, consigliamo le configurazioni indicate di seguito. 1. Utilizza il tipo di istanza più potente disponibile. 1. Attiva sempre la [precisione mista](model-parallel-core-features-v2-mixed-precision.md), poiché offre vantaggi sostanziali in termini di prestazioni e riduzione della memoria. Ti consigliamo di utilizzare `bfloat16`, che assicura maggiore precisione rispetto a `float16`. 1. Attiva la [libreria di parallelismo dei dati SageMaker distribuiti](data-parallel.md) (invece di usare NCCL) ogni volta che è applicabile, come mostrato in. [Compatibilità con la libreria SMDDP ottimizzata per l'infrastruttura AWS](model-parallel-core-features-v2-smddp-allgather.md) Un'eccezione riguarda i casi tensor-parallelism-only d'uso (e). `hybrid_shard_degree = 1` `tensor_paralle_degree > 1` 1. Se il tuo modello include più di 60 miliardi di parametri circa, ti consigliamo di utilizzare [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md). È inoltre possibile ricorrere all’inizializzazione ritardata dei parametri per velocizzare l’inizializzazione di qualsiasi modello. 1. Ti consigliamo di abilitare [Checkpoint di attivazione](model-parallel-core-features-v2-pytorch-activation-checkpointing.md). A seconda delle dimensioni del modello, ti consigliamo di iniziare attenendoti alle indicazioni fornite di seguito. 1. Utilizza la parallelizzazione dei dati sottoposti a sharding. 1. A seconda della dimensione del batch che intendi inserire nella memoria della GPU, scegli il grado di parallelizzazione dei dati sottoposti a sharding. Normalmente, è consigliabile iniziare con il grado più basso per inserire il modello nella memoria della GPU e ridurre al minimo il sovraccarico derivante dalla comunicazione di rete. Se viene visualizzato un avviso che segnala svuotamenti della cache, ti consigliamo di aumentare il grado di sharding. 1. Determina `world_size` in base alla dimensione massima del batch locale e alla dimensione del batch globale richiesta, se presente. 1. Puoi provare ad applicare l’offload dell’attivazione. A seconda degli scenari, questo può soddisfare le esigenze di memoria senza dover aumentare il grado di sharding, riducendo così la comunicazione. 1. Utilizza contemporaneamente il parallelismo dei dati frammentati di PyTorch FSDP e il parallelismo tensoriale di SMP v2, come introdotto in. [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md) 1. Quando si esegue l’addestramento su cluster di grandi dimensioni con il solo FSDP, la dimensione globale del batch può diventare eccessiva, causando problemi di convergenza per il modello. In genere, la maggior parte dei lavori di ricerca mantiene la dimensione del batch al di sotto dei 4 milioni di token. In questo caso, puoi risolvere il problema componendo PyTorch FSDP con il parallelismo tensoriale di SMP v2 per ridurre la dimensione del batch. Ad esempio, in presenza di 256 nodi e una lunghezza della sequenza pari a 4096, anche se la dimensione del batch è 1 per GPU, la dimensione globale del batch sarà di 8 milioni di token. Tuttavia, quando si utilizza la parallelizzazione tensoriale con grado 2 e la dimensione del batch è 1 per gruppo parallelo di tensori, la dimensione del batch per GPU si dimezza, portando il numero dei token a 4 milioni. 1. In caso di addestramento con contesti di notevole lunghezza, ad esempio 8.000, la memoria di attivazione pari a 16.000 può diventare molto elevata. FSDP non divide le attivazioni e le attivazioni possono causare l'esaurimento della memoria. GPUs In tali scenari, è possibile allenarsi in modo efficiente componendo PyTorch FSDP con il parallelismo tensoriale di SMP v2. ### Configurazioni di riferimento Il team di formazione sul parallelismo dei SageMaker modelli fornisce i seguenti punti di riferimento basati su esperimenti con il modello Llama 2 trasformato nel modello di trasformatore SMP utilizzando e addestrando `ml.p4d.24xlarge` istanze con lunghezza di sequenza 4096 e [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform) precisione mista (or). FP16 BF16 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/model-parallel-best-practices-v2.html) È possibile estrapolare le configurazioni precedenti per stimare l’utilizzo della memoria GPU per la configurazione del modello. Ad esempio, se aumenti la lunghezza della sequenza per un modello da 10 miliardi di parametri o aumenti le dimensioni del modello a 20 miliardi, potresti voler ridurre prima la dimensione del batch. Se il modello continua a non adattarsi, prova ad aumentare il grado di parallelizzazione tensoriale. ## Monitoraggio e registrazione di un processo di formazione utilizzando la console SageMaker AI e Amazon CloudWatch [Per monitorare metriche a livello di sistema come l'utilizzo della memoria CPU, l'utilizzo della memoria GPU e l'utilizzo della GPU, utilizza la visualizzazione fornita tramite la console AI. SageMaker ](https://console.aws.amazon.com/sagemaker/) 1. Nel pannello di navigazione a sinistra scegli **Addestramento**. 1. Scegli **Processi di addestramento**. 1. Nel riquadro principale, scegli il nome del processo di addestramento per il quale desideri visualizzare ulteriori dettagli. 1. Sfoglia il pannello principale e trova la sezione **Monitora** per vedere la visualizzazione automatizzata. 1. Per visualizzare i log dei processi di addestramento , scegli **Visualizza log** nella sezione **Monitora**. È possibile accedere ai registri distribuiti dei lavori di formazione relativi al processo di formazione in. CloudWatch Se hai avviato l’addestramento distribuito su più nodi, dovresti vedere più flussi di log con tag nel formato **algo-n-1234567890**. Il flusso di log **algo-1** tiene traccia dei log di addestramento dal nodo principale (0°). Per ulteriori informazioni, consulta [Amazon CloudWatch Metrics per il monitoraggio e l'analisi dei lavori di formazione](training-metrics.md). ## Permissions Per eseguire un processo di SageMaker formazione con il parallelismo dei modelli, assicurati di disporre delle autorizzazioni giuste nel tuo ruolo IAM, come le seguenti: + Da usare [FSx per Lustre](https://aws.amazon.com/fsx/), aggiungi. [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess) + Per utilizzare Amazon S3 come canale dati, aggiungi [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess). + Per utilizzare Docker, creare il tuo container e inviarlo ad Amazon ECR, aggiungi [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess). + Per avere accesso completo all'intera suite di funzionalità di SageMaker intelligenza artificiale, aggiungi [https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess). # Il riferimento alla libreria parallela del SageMaker modello v2 Di seguito sono riportati i riferimenti per la SageMaker model parallel library v2 (SMP v2). **Topics** + [Parametri di configurazione delle funzionalità principali di SMP v2](#distributed-model-parallel-v2-reference-init-config) + [Riferimento per il pacchetto `torch.sagemaker` di SMP v2](#model-parallel-v2-torch-sagemaker-reference) + [Aggiornamento da SMP v1 a SMP v2](#model-parallel-v2-upgrade-from-v1) ## Parametri di configurazione delle funzionalità principali di SMP v2 Di seguito è riportato un elenco completo dei parametri per l’attivazione e la configurazione di [Caratteristiche principali della libreria di parallelismo dei SageMaker modelli v2](model-parallel-core-features-v2.md). Questi devono essere scritti in formato JSON e passati allo PyTorch stimatore nell'SDK SageMaker Python o salvati come file JSON per. SageMaker HyperPod ``` { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "context_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } ``` + `hybrid_shard_degree` (Integer): specifica un grado di parallelizzazione sottoposta a sharding. Il valore deve essere un numero intero compreso tra `0` e `world_size`. Il valore predefinito è `0`. + Se impostato su`0`, torna all' PyTorchimplementazione nativa e all'API nello script quando è 1. `tensor_parallel_degree` Altrimenti, calcola il `hybrid_shard_degree` più grande possibile in base a `tensor_parallel_degree` e `world_size`. Quando si torna ai casi d'uso nativi di PyTorch FSDP, se `FULL_SHARD` è la strategia che si utilizza, si divide in tutto il cluster di. GPUs Se la strategia era `HYBRID_SHARD` o `_HYBRID_SHARD_ZERO2`, equivale a `hybrid_shard_degree` su 8. Quando la parallelizzazione è abilitata, lo shard viene eseguito in base al `hybrid_shard_degree` rivisto. + Se impostato su`1`, ritorna all' PyTorchimplementazione e all'API native dello script quando `tensor_parallel_degree` è 1. `NO_SHARD` Altrimenti, è equivalente a `NO_SHARD` all’interno di un qualsiasi gruppo parallelo di tensori. + Se impostato su un numero intero compreso tra 2 e`world_size`, lo sharding avviene sul numero specificato di. GPUs Se non imposti `sharding_strategy` nello script FSDP, viene sovrascritto da `HYBRID_SHARD`. Se imposti `_HYBRID_SHARD_ZERO2`, viene utilizzata la `sharding_strategy` specificata. + `sm_activation_offloading` (Boolean): specifica se abilitare l’implementazione dell’offload di attivazione SMP. Se`False`, l'offloading utilizza l'implementazione nativa. PyTorch Se è `True`, utilizza l’implementazione di offload di attivazione SMP. È inoltre necessario utilizzare l'offload di PyTorch attivazione wrapper (`torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper`) nello script. Per ulteriori informazioni, consulta [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md). Il valore predefinito è `True`. + `activation_loading_horizon` (Integer): specifica il tipo di orizzonte dell’offload di attivazione per FSDP. Si tratta del numero massimo di livelli sottoposti a checkpoint o offload i cui input possono trovarsi contemporaneamente nella memoria della GPU. Per ulteriori informazioni, consulta [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md). Il valore di input deve essere un numero intero positivo. Il valore predefinito è `2`. + `fsdp_cache_flush_warnings`(Boolean) — Rileva e avvisa se si verificano svuotamenti della cache nel gestore della PyTorch memoria, poiché possono ridurre le prestazioni di calcolo. Il valore predefinito è `True`. + `allow_empty_shards` (Boolean): indica se consentire shard vuoti durante lo sharding dei tensori se il tensore non è divisibile. Questa è una soluzione sperimentale per gli arresti anomali durante il checkpoint in determinati scenari. La disattivazione di questa funzionalità ritorna al comportamento originale. PyTorch Il valore predefinito è `False`. + `tensor_parallel_degree` (Integer): specifica un grado di parallelizzazione tensoriale. Il valore deve essere compreso tra `1` e `world_size`. Il valore predefinito è `1`. Tieni presente che il passaggio di un valore maggiore di 1 non abilita automaticamente la parallelizzazione del contesto; per eseguire il wrapping del modello nello script di addestramento, devi utilizzare anche l’API [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni, consulta [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md). + `context_parallel_degree` (Integer): specifica il grado di parallelizzazione del contesto. Il valore deve essere compreso tra `1` e `world_size` e deve essere `<= hybrid_shard_degree`. Il valore predefinito è `1`. Tieni presente che il passaggio di un valore maggiore di 1 non abilita automaticamente la parallelizzazione del contesto; per eseguire il wrapping del modello nello script di addestramento, devi utilizzare anche l’API [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni, consulta [Parallelizzazione del contesto](model-parallel-core-features-v2-context-parallelism.md). + `expert_parallel_degree` (Integer): specifica un grado di parallelizzazione degli esperti. Il valore deve essere compreso tra 1 e `world_size`. Il valore predefinito è `1`. Tieni presente che il passaggio di un valore maggiore di 1 non abilita automaticamente la parallelizzazione del contesto; per eseguire il wrapping del modello nello script di addestramento, devi utilizzare anche l’API [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni, consulta [Parallelizzazione degli esperti](model-parallel-core-features-v2-expert-parallelism.md). + `random_seed` (Integer): un numero di seed per le operazioni casuali nei moduli distribuiti mediante la parallelizzazione degli esperti o la parallelizzazione tensoriale di SMP. Questo seed viene aggiunto alle classificazioni dei tensori o degli esperti parallele per impostare il seed effettivo per ogni classificazione. Si tratta di un valore univoco per ogni classificazione dei tensori o degli esperti parallela. SMP v2 assicura che il numero casuale generato tra i ranghi tensor-parallel e expert-parallel corrisponda rispettivamente ai casi e. non-tensor-parallelism non-expert-parallelism ## Riferimento per il pacchetto `torch.sagemaker` di SMP v2 Questa sezione è un riferimento per il pacchetto `torch.sagemaker` fornito da SMP v2. **Topics** + [`torch.sagemaker.delayed_param.DelayedParamIniter`](#model-parallel-v2-torch-sagemaker-reference-delayed-param-init) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-async-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-state-dict-saver) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_loader.load`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-load) + [`torch.sagemaker.moe.moe_config.MoEConfig`](#model-parallel-v2-torch-sagemaker-reference-moe) + [`torch.sagemaker.nn.attn.FlashSelfAttention`](#model-parallel-v2-torch-sagemaker-reference-flashselfattention) + [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) + [`torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`](#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn) + [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) + [Proprietà e funzioni `torch.sagemaker` utili](#model-parallel-v2-torch-sagemaker-reference-utils) ### `torch.sagemaker.delayed_param.DelayedParamIniter` Un'API per l'applicazione a un modello. [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md) PyTorch ``` class torch.sagemaker.delayed_param.DelayedParamIniter( model: nn.Module, init_method_using_config : Callable = None, verbose: bool = False, ) ``` **Parametri** + `model`(`nn.Module`) — Un PyTorch modello per avvolgere e applicare la funzionalità di inizializzazione ritardata dei parametri di SMP v2. + `init_method_using_config` (Callable): se utilizzi l’implementazione della parallelizzazione tensoriale di SMP v2 o dei [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) supportati, mantieni questo parametro sul valore predefinito, ovvero `None`. Per impostazione predefinita, l’API `DelayedParamIniter` rileva come inizializzare correttamente il modello specificato. Per tutti gli altri modelli, è necessario creare una funzione di inizializzazione dei parametri personalizzata e aggiungerla allo script. Il seguente frammento di codice è la funzione `init_method_using_config` predefinita implementata da SMP v2 per [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models). Utilizza il seguente frammento di codice come riferimento per creare la tua funzione di configurazione dell’inizializzazione, aggiungerla allo script e passarla al parametro `init_method_using_config` dell’API `DelayedParamIniter` SMP. ``` from torch.sagemaker.utils.module_utils import empty_module_params, move_buffers_to_device # Define a custom init config function. def custom_init_method_using_config(module): d = torch.cuda.current_device() empty_module_params(module, device=d) if isinstance(module, (nn.Linear, Conv1D)): module.weight.data.normal_(mean=0.0, std=config.initializer_range) if module.bias is not None: module.bias.data.zero_() elif isinstance(module, nn.Embedding): module.weight.data.normal_(mean=0.0, std=config.initializer_range) if module.padding_idx is not None: module.weight.data[module.padding_idx].zero_() elif isinstance(module, nn.LayerNorm): module.weight.data.fill_(1.0) module.bias.data.zero_() elif isinstance(module, LlamaRMSNorm): module.weight.data.fill_(1.0) move_buffers_to_device(module, device=d) delayed_initer = DelayedParamIniter(model, init_method_using_config=custom_init_method_using_config) ``` Per ulteriori informazioni sulle funzioni `torch.sagemaker.module_util` relative al frammento di codice precedente, consulta [Proprietà e funzioni `torch.sagemaker` utili](#model-parallel-v2-torch-sagemaker-reference-utils). + `verbose` (Boolean): indica se abilitare una registrazione di log più dettagliata durante l’inizializzazione e la convalida. Il valore predefinito è `False`. **Metodi** + `get_param_init_fn()`— Restituisce la funzione di inizializzazione dei parametri che è possibile passare all'`param_init_fn`argomento della classe wrapper FSDP. PyTorch + `get_post_param_init_fn()`— Restituisce la funzione di inizializzazione dei parametri che è possibile passare all'`post_param_init_fn`argomento della classe wrapper FSDP. PyTorch Ciò è necessario quando nel modello sono presenti pesi condivisi. Il modello deve implementare il metodo `tie_weights`. Per ulteriori informazioni, consulta **Note sui pesi condivisi** in [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md). + `count_num_params` (`module: nn.Module, *args: Tuple[nn.Parameter]`): traccia il numero di parametri inizializzati dalla funzione di inizializzazione dei parametri. Questo aiuta a implementare il seguente metodo `validate_params_and_buffers_inited`. Di solito non è necessario chiamare questa funzione in modo esplicito, perché il metodo `validate_params_and_buffers_inited` chiama implicitamente questo metodo nel backend. + `validate_params_and_buffers_inited` (`enabled: bool=True`): si tratta di un gestore di contesto che aiuta a controllare se il numero di parametri inizializzati corrisponde al numero totale di parametri nel modello. Verifica inoltre che tutti i parametri e i buffer si trovino ora su dispositivi GPU anziché su metadispositivi. Se queste condizioni non sono soddisfatte, genera `AssertionErrors`. Questo gestore di contesto è solo facoltativo e non è necessario utilizzarlo per inizializzare i parametri. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save` API di input per il salvataggio asincrono. Utilizza questo metodo per salvare un `state_dict` in modo asincrono su un `checkpoint_id` specificato. ``` def async_save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, queue : AsyncCallsQueue = None, sharded_strategy: Union[SaveShardedStrategy, Tuple[str, int], None] = None, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parametri** + `state_dict` (dict): obbligatorio. Il dizionario degli stati da salvare. + `checkpoint_id` (str): obbligatorio. Il percorso di archiviazione in cui salvare i checkpoint. + `storage_writer`() - Facoltativo. StorageWriter Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter). + `planner`(SavePlanner) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner). + `process_group`(ProcessGroup) - Facoltativo. Il gruppo di processi su cui intervenire. Se è `None`, viene utilizzato il gruppo di processi (globale) predefinito. + `coordinator_rank` (int): facoltativo. La classificazione del coordinatore durante l’esecuzione di operatori di comunicazione collettiva come`AllReduce`. + `queue`(AsyncRequestQueue) - Facoltativo. Il pianificatore asincrono da utilizzare. Per impostazione predefinita, utilizza il parametro globale `DEFAULT_ASYNC_REQUEST_QUEUE`. + `sharded_strategy`(PyTorchDistSaveShardedStrategy) - Facoltativo. La strategia sottoposta a sharding da utilizzare per salvare i checkpoint. Se non specificata, si utilizza `torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy` per impostazione predefinita. + `wait_error_handling` (bool): facoltativo. Un flag che specifica se attendere che tutte le classificazioni completino la gestione degli errori. Il valore predefinito è `True`. + `force_check_all_plans` (bool): facoltativo. Un flag che determina se forzare la sincronizzazione dei piani tra le classificazioni, anche in caso di riscontro nella cache. Il valore predefinito è `True`. + `s3_region` (str): facoltativo. La Regione in cui si trova il bucket S3. Se non specificata, la Regione viene dedotta da `checkpoint_id`. + `s3client_config`(S3ClientConfig) - Facoltativo. La classe di dati che espone i parametri configurabili per il client S3. Se non viene fornita, viene utilizzata la configurazione predefinita di [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). Per impostazione predefinita, il parametro `part_size` è impostato su 64 MB. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls` Questa funzione consente di eseguire un job di addestramento per monitorare più richieste asincrone. ``` def maybe_finalize_async_calls( blocking=True, process_group=None ) -> List[int]: ``` **Parametri** + `blocking` (bool): facoltativo. Se `True`, attende il completamento di tutte le richieste attive. Altrimenti, finalizza solo le richieste asincrone che sono già state completate. Il valore predefinito è `True`. + `process_group`(ProcessGroup) - Facoltativo. Il gruppo di processi su cui intervenire. Se impostato su `None`, viene utilizzato il gruppo di processi (globale) predefinito. **Valori restituiti** + Un elenco contenente gli indici delle chiamate asincrone correttamente finalizzate. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.save` Utilizza questo metodo per salvare un `state_dict` in modo sincrono su un `checkpoint_id` specificato. ``` def save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parametri** + `state_dict` (dict): obbligatorio. Il dizionario degli stati da salvare. + `checkpoint_id` (str): obbligatorio. Il percorso di archiviazione in cui salvare i checkpoint. + `storage_writer`(StorageWriter) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter). + `planner`(SavePlanner) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner). + `process_group`(ProcessGroup) - Facoltativo. Il gruppo di processi su cui intervenire. Se è `None`, viene utilizzato il gruppo di processi (globale) predefinito. + `coordinator_rank` (int): facoltativo. La classificazione del coordinatore durante l’esecuzione di operatori di comunicazione collettiva come`AllReduce`. + `wait_error_handling` (bool): facoltativo. Un flag che specifica se attendere che tutte le classificazioni completino la gestione degli errori. Il valore predefinito è `True`. + `force_check_all_plans` (bool): facoltativo. Un flag che determina se forzare la sincronizzazione dei piani tra le classificazioni, anche in caso di riscontro nella cache. Il valore predefinito è `True`. + `s3_region` (str): facoltativo. La Regione in cui si trova il bucket S3. Se non specificata, la Regione viene dedotta da `checkpoint_id`. + `s3client_config`(S3ClientConfig) - Facoltativo. La classe di dati che espone i parametri configurabili per il client S3. Se non viene fornita, viene utilizzata la configurazione predefinita di [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). Per impostazione predefinita, il parametro `part_size` è impostato su 64 MB. ### `torch.sagemaker.distributed.checkpoint.state_dict_loader.load` Carica il dizionario di stato di un modello distribuito (`state_dict`). ``` def load( state_dict: Dict[str, Any], *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_reader: Optional[StorageReader] = None, planner: Optional[LoadPlanner] = None, process_group: Optional[dist.ProcessGroup] = None, check_keys_matched: bool = True, coordinator_rank: int = 0, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parametri** + `state_dict` (dict): obbligatorio. Il `state_dict` da caricare. + `checkpoint_id` (str): obbligatorio. L’ID di un checkpoint. Il significato di `checkpoint_id` dipende dallo spazio di archiviazione. Può essere il percorso di una cartella o un file. Può anche essere una chiave, se lo strumento di archiviazione è un archivio chiave-valore. + `storage_reader`(StorageReader) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader)in PyTorch per eseguire operazioni di lettura. Se non specificato, il checkpoint distribuito dedurrà automaticamente il lettore in base a `checkpoint_id`. Se `checkpoint_id` è anche `None`, viene generato un errore di eccezione. + `planner`(StorageReader) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner)in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner). + `check_keys_matched` (bool): facoltativo. Se abilitato, controlla la corrispondenza delle chiavi `state_dict` di tutte le classificazioni utilizzando `AllGather`. + `s3_region` (str): facoltativo. La Regione in cui si trova il bucket S3. Se non specificata, la Regione viene dedotta da `checkpoint_id`. + `s3client_config`(S3ClientConfig) - Facoltativo. La classe di dati che espone i parametri configurabili per il client S3. Se non viene fornita, viene utilizzata la configurazione predefinita di [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). Per impostazione predefinita, il parametro `part_size` è impostato su 64 MB. ### `torch.sagemaker.moe.moe_config.MoEConfig` Una classe di configurazione per configurare l'implementazione SMP di Mixture-of-Experts (MoE). È possibile specificare i valori di configurazione di MoE tramite questa classe e passarli alla chiamata API [https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni sull’utilizzo di questa classe per l’addestramento dei modelli MoE, consulta [Parallelizzazione degli esperti](model-parallel-core-features-v2-expert-parallelism.md). ``` class torch.sagemaker.moe.moe_config.MoEConfig( smp_moe=True, random_seed=12345, moe_load_balancing="sinkhorn", global_token_shuffle=False, moe_all_to_all_dispatcher=True, moe_aux_loss_coeff=0.001, moe_z_loss_coeff=0.001 ) ``` **Parametri** + `smp_moe` (Boolean): indica se utilizzare l’implementazione SMP di MoE. Il valore predefinito è `True`. + `random_seed` (Integer): un numero di seed per le operazioni casuali nei moduli distribuiti mediante la parallelizzazione degli esperti. Questo seed viene aggiunto alla classificazione degli esperti parallela per impostare il seed effettivo per ogni classificazione. Si tratta di un valore univoco per ogni classificazione degli esperti parallela. Il valore predefinito è `12345`. + `moe_load_balancing` (String): specifica il tipo di bilanciatore del carico del router MoE. Le opzioni valide sono `aux_loss`, `sinkhorn`, `balanced` e `none`. Il valore predefinito è `sinkhorn`. + `global_token_shuffle` (Boolean): indica se eseguire lo shuffling dei token tra le classificazioni EP all’interno dello stesso gruppo EP. Il valore predefinito è `False`. + `moe_all_to_all_dispatcher`(Boolean) - Indica se usare il all-to-all dispatcher per le comunicazioni in MoE. Il valore predefinito è `True`. + `moe_aux_loss_coeff` (Float): un coefficiente per la perdita ausiliaria di bilanciamento del carico. Il valore predefinito è `0.001`. + `moe_z_loss_coeff` (Float): coefficiente per z-loss. Il valore predefinito è `0.001`. ### `torch.sagemaker.nn.attn.FlashSelfAttention` Un’API per l’utilizzo di [FlashAttention](model-parallel-core-features-v2-flashattention.md) con SMP v2. ``` class torch.sagemaker.nn.attn.FlashSelfAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, triton_flash_attention: bool = False, use_alibi: bool = False, ) ``` **Parametri** + `attention_dropout_prob` (float): la probabilità di abbandono da applicare all’attenzione. Il valore predefinito è `0.0`. + `scale` (float): se passato, questo fattore di scala viene applicato per softmax. Se impostato su `None` (che è anche il valore predefinito), il fattore di scala è `1 / sqrt(attention_head_size)`. Il valore predefinito è `None`. + `triton_flash_attention` (bool): se passato, viene utilizzata l’implementazione Triton dell’attenzione flash. Ciò è necessario per supportare Attention with Linear Biases (ALiBi) (si veda il seguente parametro). `use_alibi` Questa versione del kernel non supporta il dropout. Il valore predefinito è `False`. + `use_alibi`(bool) — Se superato, abilita l'opzione Attention with Linear Biases (ALiBi) utilizzando la maschera fornita. Quando si usa ALi Bi, è necessaria una maschera di attenzione preparata come segue. Il valore predefinito è `False`. ``` def generate_alibi_attn_mask(attention_mask, batch_size, seq_length, num_attention_heads, alibi_bias_max=8): device, dtype = attention_mask.device, attention_mask.dtype alibi_attention_mask = torch.zeros( 1, num_attention_heads, 1, seq_length, dtype=dtype, device=device ) alibi_bias = torch.arange(1 - seq_length, 1, dtype=dtype, device=device).view( 1, 1, 1, seq_length ) m = torch.arange(1, num_attention_heads + 1, dtype=dtype, device=device) m.mul_(alibi_bias_max / num_attention_heads) alibi_bias = alibi_bias * (1.0 / (2 ** m.view(1, num_attention_heads, 1, 1))) alibi_attention_mask.add_(alibi_bias) alibi_attention_mask = alibi_attention_mask[..., :seq_length, :seq_length] if attention_mask is not None and attention_mask.bool().any(): alibi_attention_mask.masked_fill( attention_mask.bool().view(batch_size, 1, 1, seq_length), float("-inf") ) return alibi_attention_mask ``` **Metodi** + `forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d")`— Una normale funzione PyTorch del modulo. Quando viene chiamato un `module(x)`, SMP esegue questa funzione automaticamente. + `qkv`: `torch.Tensor` con la forma `(batch_size x seqlen x (3 x num_heads) x head_size)` o `(batch_size, (3 x num_heads) x seqlen x head_size)` seguente, una tupla che include `torch.Tensors`, ciascuno dei quali potrebbe avere una forma `(batch_size x seqlen x num_heads x head_size)` oppure `(batch_size x num_heads x seqlen x head_size)`. È necessario passare un argomento di layout appropriato in base alla forma. + `attn_mask`: `torch.Tensor` con la forma `(batch_size x 1 x 1 x seqlen)` seguente. L’abilitazione di questo parametro della maschera di attenzione richiede `triton_flash_attention=True` e `use_alibi=True`. Per informazioni su come generare una maschera di attenzione utilizzando questo metodo, consulta gli esempi di codice disponibili in [FlashAttention](model-parallel-core-features-v2-flashattention.md). Il valore predefinito è `None`. + `causal`: quando è impostato su `False`, ovvero il valore predefinito dell’argomento, non viene applicata alcuna maschera. Quando è impostato su `True`, il metodo `forward` utilizza la maschera triangolare inferiore standard. Il valore predefinito è `False`. + `cast_dtype`: quando è impostato su un `dtype` particolare, esegue il casting dei tensori `qkv` su tale `dtype` prima che su `attn`. Questo risulta utile per le implementazioni come il modello Hugging Face Transformers GPT-NeoX, che presenta `q` e `k` con `fp32` dopo gli embedding rotativi. Se è impostato su `None`, non viene applicato alcun cast. Il valore predefinito è `None`. + `layout` (string): i valori disponibili sono `b h s d` o `b s h d`. Dovrebbe essere impostato sul layout dei tensori `qkv` passati, in modo da poter applicare le trasformazioni appropriate per `attn`. Il valore predefinito è `b h s d`. **Valori restituiti** Un solo `torch.Tensor` con forma `(batch_size x num_heads x seq_len x head_size)`. ### `torch.sagemaker.nn.attn.FlashGroupedQueryAttention` Un’API per l’utilizzo di `FlashGroupedQueryAttention` con SMP v2. Per ulteriori informazioni sull’utilizzo di questa API, consulta [Usa i FlashAttention kernel per attirare l'attenzione sulle query raggruppate](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.attn.FlashGroupedQueryAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, ) ``` **Parametri** + `attention_dropout_prob` (float): la probabilità di abbandono da applicare all’attenzione. Il valore predefinito è `0.0`. + `scale` (float): se passato, questo fattore di scala viene applicato per softmax. Se impostato su `None`, come fattore di scala viene utilizzato `1 / sqrt(attention_head_size)`. Il valore predefinito è `None`. **Metodi** + `forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")`— Una normale funzione PyTorch del modulo. Quando viene chiamato un `module(x)`, SMP esegue questa funzione automaticamente. + `q`: `torch.Tensor` con la forma `(batch_size x seqlen x num_heads x head_size)` o `(batch_size x num_heads x seqlen x head_size)` seguente. È necessario passare un argomento di layout appropriato in base alla forma. + `kv`: `torch.Tensor` con la forma `(batch_size x seqlen x (2 x num_heads) x head_size)` o `(batch_size, (2 x num_heads) x seqlen x head_size)` seguente, una tupla che include due `torch.Tensor`, ciascuno dei quali potrebbe avere una forma `(batch_size x seqlen x num_heads x head_size)` oppure `(batch_size x num_heads x seqlen x head_size)`. È inoltre necessario passare un argomento `layout` appropriato in base alla forma. + `causal`: quando è impostato su `False`, ovvero il valore predefinito dell’argomento, non viene applicata alcuna maschera. Quando è impostato su `True`, il metodo `forward` utilizza la maschera triangolare inferiore standard. Il valore predefinito è `False`. + `cast_dtype`: quando è impostato su un dtype particolare, esegue il casting dei tensori `qkv` su tale dtype prima che su `attn`. Questo risulta utile per le implementazioni come Hugging Face Transformer GPT-NeoX, che presenta `q,k` con `fp32` dopo gli embedding rotativi. Se è impostato su `None`, non viene applicato alcun cast. Il valore predefinito è `None`. + layout (string): i valori disponibili sono `"b h s d"` o `"b s h d"`. Dovrebbe essere impostato sul layout dei tensori `qkv` passati, in modo da poter applicare le trasformazioni appropriate per `attn`. Il valore predefinito è `"b h s d"`. **Valori restituiti** Restituisce un solo `torch.Tensor (batch_size x num_heads x seq_len x head_size)`, che rappresenta l’output del calcolo dell’attenzione. ### `torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention` Un'API che supporta FlashAttention il modello Llama. Questa API utilizza l’API [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) a basso livello. Per informazioni su come utilizzarla, consulta [Usa i FlashAttention kernel per attirare l'attenzione sulle query raggruppate](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention( config: LlamaConfig ) ``` **Parametri** + `config`— Una FlashAttention configurazione per il modello Llama. **Metodi** + `forward(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)` + `hidden_states` (`torch.Tensor`): stati nascosti di un tensore sotto forma di `(batch_size x seq_len x num_heads x head_size)`. + `attention_mask` (`torch.LongTensor`): maschera per evitare di applicare l’attenzione agli indici dei token di padding sotto forma di `(batch_size x seqlen)`. Il valore predefinito è `None`. + `position_ids` (`torch.LongTensor`): quando non è `None`, si presenta sotto forma di `(batch_size x seqlen)`, a segnalare gli indici di posizione di ogni token della sequenza di input negli embedding di posizione. Il valore predefinito è `None`. + `past_key_value` (Cache): stati nascosti pre-calcolati (chiave e valori nei blocchi di auto-attenzione e nei blocchi di attenzione incrociata). Il valore predefinito è `None`. + `output_attentions` (bool): indica se restituire i tensori di attenzione di tutti i livelli di attenzione. Il valore predefinito è `False`. + `use_cache` (bool): indica se restituire gli stati chiave-valore `past_key_values`. Il valore predefinito è `False`. **Valori restituiti** Restituisce un solo `torch.Tensor (batch_size x num_heads x seq_len x head_size)`, che rappresenta l’output del calcolo dell’attenzione. ### `torch.sagemaker.transform` SMP v2 fornisce questa API `torch.sagemaker.transform()` per trasformare i modelli di Hugging Face Transformer in implementazioni di modelli SMP e abilitare la parallelizzazione tensoriale SMP. ``` torch.sagemaker.transform( model: nn.Module, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None, config: Optional[Dict] = None, load_state_dict_from_rank0: bool = False, cp_comm_type: str = "p2p" ) ``` SMP v2 mantiene le policy di trasformazione per i [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) convertendo la configurazione dei modelli di Hugging Face Transformer in configurazione del trasformatore SMP. **Parametri** + `model` (`torch.nn.Module`): uno dei [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) per trasformare e applicare la funzionalità di parallelizzazione tensoriale della libreria SMP. + `device` (`torch.device`): se passato, viene creato un nuovo modello su questo dispositivo. Se il modulo originale dispone di qualche parametro su metadispositivo (vedi [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md)), allora il modulo trasformato verrà creato anche sul metadispositivo, ignorando l’argomento passato qui. Il valore predefinito è `None`. + `dtype` (`torch.dtype`): se passato, lo imposta come gestore di contesto dtype per la creazione del modello e crea un modello utilizzando questo dtype. In genere non è necessario, poiché vogliamo creare il modello con `fp32` cui lo utilizziamo `MixedPrecision` ed `fp32` è il dtype predefinito in. PyTorch Il valore predefinito è `None`. + `config` (dict): dizionario per la configurazione del trasformatore SMP. Il valore predefinito è `None`. + `load_state_dict_from_rank0` (Boolean): per impostazione predefinita, questo modulo crea una nuova istanza del modello con nuovi pesi. Quando questo argomento è impostato su`True`, SMP tenta di caricare il dizionario di stato del PyTorch modello originale dal rango 0 al modello trasformato per il gruppo parallelo tensoriale di cui fa parte il rango 0. Quando è impostato su `True`, la classificazione 0 non può avere alcun parametro su metadispositivi. Dopo questa chiamata di trasformazione, solo il primo gruppo tensoriale parallelo popola i pesi ricavandoli dalla classificazione 0. Per estendere questi pesi dal primo gruppo tensoriale parallelo a tutti gli altri processi, è necessario impostare `sync_module_states` su `True` nel wrapper FSDP. Con questa opzione attivata, la libreria SMP carica il dizionario degli stati dal modello originale. La libreria SMP prende il `state_dict` del modello prima della trasformazione, lo converte in modo che corrisponda alla struttura del modello trasformato, ne esegue lo sharding per ogni classificazione tensoriale parallela, comunica questo stato dalla classificazione 0 ad altre classificazioni nel gruppo tensoriale parallelo di cui fa parte la classificazione 0 e lo carica. Il valore predefinito è `False`. + `cp_comm_type` (str): determina l’implementazione della parallelizzazione del contesto ed è applicabile solo quando `context_parallel_degree` è maggiore di 1. I valori disponibili per questo parametro sono `p2p` e `all_gather`. L'`p2p`implementazione utilizza chiamate di peer-to-peer invio e ricezione per l'accumulo del tensore key-and-value (KV) durante il calcolo dell'attenzione, eseguite in modo asincrono e consentono la sovrapposizione della comunicazione con il calcolo. L’implementazione `all_gather` utilizza invece l’operazione collettiva di comunicazione `AllGather` per l’accumulo di tensori KV. Il valore predefinito è `"p2p"`. **Valori restituiti** Restituisce un modello PyTorch trasformato che puoi avvolgere con FSDP. Quando `load_state_dict_from_rank0` è impostato su `True`, il gruppo tensoriale parallelo che coinvolge la classificazione 0 include pesi caricati dal dizionario degli stati originale della classificazione 0. Quando vengono utilizzati [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md) sul modello originale, solo questi ranghi hanno i tensori effettivi attivi CPUs per i parametri e i buffer del modello trasformato. Il resto delle classificazioni continua ad avere i parametri e i buffer sul metadispositivo per risparmiare memoria. ### Proprietà e funzioni `torch.sagemaker` utili **funzioni torch.sagemaker utili** + `torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None`— Inizializza il processo di formazione con SMP. PyTorch + `torch.sagemaker.is_initialized() -> bool`: verifica se il job di addestramento è inizializzato con SMP. **Quando si torna alla versione nativa PyTorch mentre il lavoro è inizializzato con SMP, alcune proprietà non sono pertinenti e lo diventano`None`, come indicato nel seguente elenco di proprietà.** + `torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module`: crea parametri vuoti su un determinato `device`, se presente, e può essere ricorsivo per tutti i moduli annidati, se specificato. + `torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module`— Sposta i buffer dei moduli nella posizione specificata e`device`, se specificato, può essere ricorsivo per tutti i moduli annidati. **Properties** `torch.sagemaker.state` contiene più proprietà utili dopo l’inizializzazione di SMP con `torch.sagemaker.init`. + `torch.sagemaker.state.hybrid_shard_degree` (int): il grado di parallelizzazione dei dati sottoposti a sharding, una copia dell’input dell’utente nella configurazione SMP passata a `torch.sagemaker.init()`. Per ulteriori informazioni, consulta [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). + `torch.sagemaker.state.rank` (int): la classificazione globale del dispositivo, nell’intervallo di `[0, world_size)`. + `torch.sagemaker.state.rep_rank_process_group` (`torch.distributed.ProcessGroup`): il gruppo di job che include tutti i dispositivi con la stessa classificazione di replica. È importante notare la differenza lieve, ma fondamentale rispetto a `torch.sagemaker.state.tp_process_group`. Quando si ritorna alla modalità nativa PyTorch, viene restituita. `None` + `torch.sagemaker.state.tensor_parallel_degree` (int): il grado di parallelizzazione dei dati, una copia dell’input dell’utente nella configurazione SMP passata a `torch.sagemaker.init()`. Per ulteriori informazioni, consulta [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). + `torch.sagemaker.state.tp_size` (int): un alias per `torch.sagemaker.state.tensor_parallel_degree`. + `torch.sagemaker.state.tp_rank` (int): il grado di parallelizzazione tensoriale per il dispositivo nell’intervallo di `[0, tp_size)`, determinato dal grado di parallelizzazione tensoriale e dal meccanismo di classificazione. + `torch.sagemaker.state.tp_process_group` (`torch.distributed.ProcessGroup`): il gruppo di processi tensoriali paralleli che include tutti i dispositivi con la stessa classificazione in altre dimensioni (ad esempio, replica e parallelizzazione dei dati sottoposti a sharding), ma classificazioni tensoriali parallele uniche. Quando ritorna al nativo PyTorch, ritorna`None`. + `torch.sagemaker.state.world_size` (int): il numero totale di dispositivi utilizzati durante l’addestramento. ## Aggiornamento da SMP v1 a SMP v2 Per passare da SMP v1 a SMP v2, è necessario apportare modifiche allo script per rimuovere l'SMP v1 e applicare l'SMP APIs v2. APIs Invece di iniziare dallo script SMP v1, si consiglia di iniziare da uno script FSDP e seguire le istruzioni riportate all'indirizzo. PyTorch [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md) Per trasferire i *modelli* da SMP v1 a SMP v2, è necessario raccogliere il dizionario completo degli stati del modello in SMP v1 e applicarvi le funzioni di traduzione per convertirlo nel formato checkpoint del modello Hugging Face Transformers. Quindi in SMP v2, come discusso in[Checkpointing con SMP](model-parallel-core-features-v2-checkpoints.md), è possibile caricare i checkpoint del modello Hugging Face Transformers e quindi continuare a utilizzare il checkpoint con SMP v2. PyTorch APIs Per utilizzare SMP con il modello PyTorch FSDP, assicuratevi di passare a SMP v2 e di apportare modifiche allo script di addestramento per utilizzare FSDP e altre funzionalità più recenti. PyTorch ``` import smdistributed.modelparallel.torch as smp # Create model model = ... model = smp.DistributedModel(model) # Run training ... # Save v1 full checkpoint if smp.rdp_rank() == 0: model_dict = model.state_dict(gather_to_rank0=True) # save the full model # Get the corresponding translation function in smp v1 and translate if model_type == "gpt_neox": from smdistributed.modelparallel.torch.nn.huggingface.gptneox import translate_state_dict_to_hf_gptneox translated_state_dict = translate_state_dict_to_hf_gptneox(state_dict, max_seq_len=None) # Save the checkpoint checkpoint_path = "checkpoint.pt" if smp.rank() == 0: smp.save( {"model_state_dict": translated_state_dict}, checkpoint_path, partial=False, ) ``` Per informazioni sulle funzioni di traduzione disponibili in SMP v1, consulta [Supporto per i modelli Hugging Face Transformer](model-parallel-extended-features-pytorch-hugging-face.md). Per istruzioni sul salvataggio e il caricamento dei checkpoint dei modelli in SMP v2, consulta [Checkpointing con SMP](model-parallel-core-features-v2-checkpoints.md). # Note di rilascio per la libreria di parallelismo dei SageMaker modelli Consultate le seguenti note di rilascio per tenere traccia degli ultimi aggiornamenti per la libreria SageMaker Model Parallelism (SMP). Se hai altre domande sulla libreria SMP, contatta il team di assistenza SMP all’indirizzo `sm-model-parallel-feedback@amazon.com`. ## La libreria di SageMaker parallelismo dei modelli v2.8.0 *Data: 01 aprile 2025* ### Aggiornamenti della libreria SMP **Correzioni di bug** + Il clipping della norma del gradiente di SMP ora supporta l’offload di attivazione. ### Container Docker ed Enroot di SMP Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se utilizzi la classe PyTorch estimator in SageMaker Python SDK e specifichi la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK a o versioni successive. `v2.243.0` **Aggiornamenti sulla valuta** + È stato aggiunto il supporto per la versione 2.5.1 PyTorch + Supporto CUDA aggiornato alla v12.4 + Supporto NCCL aggiornato alla v2.23.4 + Libreria SMDDP aggiornata alla v2.6.0 **Dettagli container** + Contenitore SMP Docker per PyTorch v2.5.1 con CUDA v12.4 ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.5.1-gpu-py311-cu124 ``` + Contenitore SMP Enroot per v2.5.1 con CUDA v12.4 PyTorch ``` https://sagemaker-distributed-model-parallel.s3..amazonaws.com/enroot/2.5.1-gpu-py311-cu124.sqsh ``` + Pacchetti preinstallati + Libreria SMP v2.8.0 + Libreria SMDDP v2.6.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Libreria Hugging Face Datasets v2.19.0 + EFA v1.36.0 + NCCL v2.23.4 + AWS-OFI-NCCL v1.13.2 ### Canale Conda di SMP Il seguente bucket S3 è il canale Conda pubblico della libreria SMP ospitata dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. ## La libreria di parallelismo dei modelli v2.7.0 SageMaker *Data: 04 dicembre 2024* ### Aggiornamenti della libreria SMP **Nuove funzionalità** + Aggiunta del supporto per [SageMaker HyperPod ricette](sagemaker-hyperpod-recipes.md). ### Container Docker ed Enroot di SMP Il team della libreria SMP distribuisce i contenitori Docker ed Enroot in sostituzione dei contenitori del framework. SageMaker PyTorch Se si utilizza la classe PyTorch estimator in SageMaker Python SDK e si specifica la configurazione di distribuzione per utilizzare SMP v2 SageMaker, preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK a o versioni successive. `v2.237.0` **Dettagli container** + Contenitore SMP Docker per v2.4.1 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr..smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` + Contenitore SMP Enroot per v2.4.1 con CUDA v12.1 PyTorch ``` https://sagemaker-distributed-model-parallel.s3..amazonaws.com/enroot/2.4.1-gpu-py311-cu121.sqsh ``` + Pacchetti preinstallati + Libreria SMP v2.7.0 + Libreria SMDDP v2.5.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Libreria Hugging Face Datasets v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### Canale Conda di SMP Il seguente bucket S3 è il canale Conda pubblico della libreria SMP ospitata dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente Conda come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. ## La libreria di parallelismo dei modelli v2.6.1 SageMaker *Data: 31 ottobre 2024* ### Aggiornamenti della libreria SMP **Correzioni di bug** + Risoluzione di un problema `ImportError` che si verificava durante l’utilizzo di script di addestramento precedenti con SMP v2.6.0. Questo corregge l’incompatibilità con le precedenti versioni di SMP v2.6.0. + Aggiunta di un `DeprecationWarning` per `torch.sagemaker.distributed.fsdp.checkpoint`. Questo modulo diventerà obsoleto e sarà rimosso in SMP v2.7.0. Se al momento stai utilizzando `torch.sagemaker.distributed.fsdp.checkpoint` nel tuo codice, dovresti pianificare l’aggiornamento degli script prima del rilascio di SMP v2.7.0 per evitare problemi futuri. + Risoluzione di un problema di compatibilità con le versioni precedenti identificato in SMP v2.6.0. Questo problema era correlato all’obsolescenza del metodo di checkpoint `USE_PG_WITH_UTIL` in SMP v2.6.0, che comprometteva la compatibilità con le versioni precedenti degli script di addestramento. Per risolvere questo problema, esegui nuovamente i lavori di PyTorch formazione per ritirare il contenitore SMP più recente fornito con SMP v2.6.1. ### Container Docker di SMP Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se utilizzi la classe PyTorch estimator in SageMaker Python SDK e specifichi la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. **Dettagli container** + Contenitore SMP Docker per v2.4.1 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` + Pacchetti preinstallati + Libreria SMP v2.6.1 + Libreria SMDDP v2.5.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Libreria Hugging Face Datasets v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### Canale Conda di SMP Il seguente bucket S3 è il canale Conda pubblico della libreria SMP ospitata dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente di risorse di calcolo altamente personalizzabili come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. ## La libreria di parallelismo dei modelli v2.6.0 SageMaker *Data: 17 ottobre 2024* ### Aggiornamenti della libreria SMP **Nuove funzionalità** + Aggiunta del supporto per le seguenti configurazioni del modello LLM. Puoi iniziare a utilizzare [Parallelizzazione del contesto](model-parallel-core-features-v2-context-parallelism.md) e [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md). + [Llama3.1 8B](https://huggingface.co/meta-llama/Llama-3.1-8B) + [Llama3.1 70B](https://huggingface.co/meta-llama/Llama-3.1-70B) + [Mistral 7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) + Aggiunta del supporto di [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md) per le seguenti configurazioni del modello Mixtral. + [Mixtral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) + [Mixtral 8x22B](https://huggingface.co/mistralai/Mixtral-8x22B-v0.1) + È stato aggiunto il supporto per un'implementazione AllGather basata sul parallelismo di contesto che utilizza il collettivo di AllGather comunicazione per ottenere la sequenza completa di tensori. key-and-value Le implementazioni disponibili sono `p2p` e `all_gather`. L'`p2p`implementazione utilizza chiamate di peer-to-peer invio e ricezione per l'accumulo di tensori key-and-value (KV) durante il calcolo dell'attenzione, eseguite in modo asincrono e consentono la sovrapposizione della comunicazione con il calcolo. L’implementazione `all_gather` utilizza invece l’operazione collettiva di comunicazione `AllGather` per l’accumulo di tensori KV. Per informazioni su come applicare l’implementazione della parallelizzazione del contesto, consulta [Parallelizzazione del contesto](model-parallel-core-features-v2-context-parallelism.md). + Aggiunta del supporto per l’ottimizzazione del valore theta del Rotary Position Embedding (RoPE). **Correzioni di bug** + Risoluzione di un bug che impediva la corretta inizializzazione del Rotary Position Embedding (RoPE) durante il preaddestramento quando il parametro di ritardo era abilitato. **Problemi noti** + Transformer Engine attualmente non supporta il parallelismo contestuale o la funzionalità Sliding Window Attenzione abilitata. FP8 Pertanto, la versione SMP dei trasformatori Mistral non supporta il parallelismo di contesto o l' FP8 addestramento quando la configurazione della finestra scorrevole è impostata su un valore non nullo. ### Container Docker di SMP Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se utilizzi la classe PyTorch estimator in SageMaker Python SDK e specifichi la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. **Aggiornamenti sulla valuta** + Aggiornato alla v2.4.1 PyTorch + Megatron aggiornato alla v0.8.0 + È stata aggiornata la libreria alla v1.10 TransformerEngine + Transformer aggiornati alla v4.44.2 + cuDNN aggiornato alla v9.4.0.58 **Dettagli container** + Contenitore SMP Docker per v2.4.1 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` + Pacchetti preinstallati + Libreria SMP v2.6.0 + Libreria SMDDP v2.5.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Libreria Hugging Face Datasets v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### Canale Conda di SMP Il seguente bucket S3 è il canale Conda pubblico della libreria SMP ospitata dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente di risorse di calcolo altamente personalizzabili come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. ## La libreria di parallelismo dei modelli v2.5.0 SageMaker *Data: 28 agosto 2024* ### Aggiornamenti della libreria SMP **Nuove funzionalità** + È stato aggiunto il supporto per l'addestramento a precisione mista utilizzando il formato FP8 dati su istanze P5 per il modello Mixtral. + Le configurazioni Mixtral supportate sono 8x7B e 8x22B. Per ulteriori informazioni, consulta [Addestramento di precisione misto con nessuna istanza P5 utilizzando Transformer Engine FP8](model-parallel-core-features-v2-mixed-precision.md#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5). + Aggiunta del supporto per [Parallelizzazione del contesto](model-parallel-core-features-v2-context-parallelism.md) per le seguenti configurazioni di modello. + Llama-v2: 7B e 70B + Llama-v3: 8B e 70B + GPT-NeoX: 20B + Aggiunta del supporto per il salvataggio asincrono dei checkpoint. Per ulteriori informazioni, consulta [Checkpointing con SMP](model-parallel-core-features-v2-checkpoints.md). + Supporto per il salvataggio diretto dei checkpoint su S3 senza utilizzare Amazon EBS o file server. **Correzioni di bug** + Risoluzione di un problema che causava una perdita iniziale inaspettatamente elevata durante il fine-tuning di Llama durante il caricamento di un checkpoint del modello preaddestrato e l’utilizzo della parallelizzazione tensoriale. **Note** + Per utilizzare il checkpoint di attivazione per Mixtral con precisione FP8 mista, dovrai controllare separatamente i livelli Attenzione ed Esperto. Per un esempio di configurazione corretta, consulta lo [script di formazione di esempio](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/shared-scripts/train_utils.py) nel *repository Amazon SageMaker AI Examples*. **Problemi noti** + Il tipo di bilanciamento del carico bilanciato nella configurazione MoE ([`torch.sagemaker.moe.moe_config.MoEConfig`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-moe)) è attualmente incompatibile con il checkpoint di attivazione. + Con la parallelizzazione del contesto, GPT-NeoX mostra una regressione delle prestazioni sia durante il preaddestramento che durante il fine-tuning. + Per quanto riguarda GPT-NeoX su istanze P4, il caricamento diretto dei pesi da un modello trasformato inizializzato con il parametro di ritardo in un modello di trasformatore Hugging Face comporta una discrepanza nelle perdite durante la prima fase. ### Container Docker di SMP Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se utilizzi la classe PyTorch estimator in SageMaker Python SDK e specifichi la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK alla versione 2.224.0 o successiva. **Aggiornamenti sulla valuta** + FlashAttention È stata aggiornata la libreria alla versione 2.5.8 + Libreria Transformer Engine aggiornata alla v1.8 + Se desideri installare Transformer Engine in un ambiente Conda, devi compilarlo dalla sorgente e selezionare le correzioni upstream specifiche ([744624d](https://github.com/NVIDIA/TransformerEngine/commit/744624d004f4514ffbaa90ac83e214311c86c607), [27c6342](https://github.com/NVIDIA/TransformerEngine/commit/27c6342ea8ad88034bf04b587dd13cb6088d2474), [7669bf3](https://github.com/NVIDIA/TransformerEngine/commit/7669bf3da68074517b134cd6acebd04b221fd545)). **Dettagli container** + Contenitore SMP Docker per v2.3.1 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.3.1-gpu-py311-cu121 ``` Per un elenco completo delle aree supportate, vedere [Regioni AWS](distributed-data-parallel-support.md#distributed-data-parallel-availablity-zone). + Pacchetti preinstallati + Libreria SMP v2.5.0 + Libreria SMDDP v2.3.0 + CUDNN v8.9.7.29 + FlashAttention v2.5.8 + TransformerEngine v1.8 + Megatron v0.7.0 + Hugging Face Transformers v4.40.1 + Libreria Hugging Face Datasets v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### Canale Conda di SMP Il seguente bucket S3 è il canale Conda pubblico della libreria SMP ospitata dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente di risorse di calcolo altamente personalizzabili come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. ## La libreria di parallelismo dei modelli v2.4.0 SageMaker *Data: 20 giugno 2024* ### Aggiornamenti della libreria SMP **Correzioni di bug** + Correzione di un bug che causava forme di logit errate quando le etichette non venivano passate in avanti durante l’utilizzo di SMP Transformer. **Aggiornamenti sulla valuta** + È stato aggiunto il supporto per la versione 2.3.1. PyTorch + Aggiunta del supporto per Python v3.11. + Aggiunta del supporto per la libreria Hugging Face Transformers v4.40.1. **Deprecazioni** + Interruzione del supporto per Python v3.10. + Interruzione del supporto per le versioni della libreria Hugging Face Transformers precedenti alla v4.40.1. **Altre modifiche** + Inclusione di una patch per attivare il salvataggio di tensori deduplicati in diverse classificazioni. Per saperne di più, consulta il [thread di discussione nel repository.](https://github.com/pytorch/pytorch/pull/126569) PyTorch GitHub **Problemi noti** + È noto che la perdita potrebbe aumentare e poi riprendere a un valore di perdita più elevato durante il fine-tuning di Llama-3 70B con la parallelizzazione tensoriale. ### Container Docker di SMP Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se utilizzi la classe PyTorch estimator in SageMaker Python SDK e specifichi la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK alla versione 2.224.0 o successiva. **Aggiornamenti sulla valuta** + Libreria SMDDP aggiornata alla v2.3.0. + Libreria NCCL aggiornata alla v2.21.5. + Software EFA aggiornato alla v1.32.0. **Deprecazioni** + Interruzione dell’installazione della [libreria Torch Distributed Experimental (torchdistX)](https://pytorch.org/torchdistx/latest/index.html). **Dettagli container** + Contenitore SMP Docker per v2.3.1 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.3.1-gpu-py311-cu121 ``` + Pacchetti preinstallati + Libreria SMP v2.4.0 + Libreria SMDDP v2.3.0 + CUDNN v8.9.7.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.40.1 + Libreria Hugging Face Datasets v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### Canale Conda di SMP Il seguente bucket S3 è il canale Conda pubblico della libreria SMP ospitata dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente di risorse di calcolo altamente personalizzabili come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. ## La libreria di parallelismo dei modelli v2.3.1 SageMaker *Data: 9 maggio 2024* **Correzioni di bug** + Risoluzione di un problema `ImportError` relativo all’utilizzo di `moe_load_balancing=balanced` in [`torch.sagemaker.moe.moe_config.MoEConfig`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-moe) per la parallelizzazione degli esperti. + Risoluzione di un problema di fine-tuning nei casi in cui la chiamata [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform) generava un `KeyError` quando `load_state_dict_from_rank0` era abilitato. + È stato corretto un errore out-of-memory (OOM) che si verificava durante il caricamento di modelli Mixture of Experts (MoE) di grandi dimensioni, come Mixtral 8x22B, per la messa a punto. **Container Docker di SMP** Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Questa versione incorpora le correzioni di bug sopra citate nella seguente immagine Docker di SMP. + Contenitore SMP Docker per v2.2.0 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` ## La SageMaker libreria di parallelismo dei modelli v2.3.0 *Data: 11 aprile 2024* **Nuove funzionalità** + Aggiunta di una nuova funzionalità di base, la *parallelizzazione degli esperti*, per supportare i modelli di trasformatori Mixture of Experts. Per ulteriori informazioni, consulta [Parallelizzazione degli esperti](model-parallel-core-features-v2-expert-parallelism.md). **Container Docker di SMP** Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se si utilizza la classe PyTorch estimator in SageMaker Python SDK e si specifica la configurazione di distribuzione per utilizzare SMP v2 SageMaker , preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK alla versione 2.214.4 o successiva. + Contenitore SMP Docker per v2.2.0 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` + Pacchetti preinstallati in questo container Docker + Libreria SMDDP v2.2.0 + CUDNN v8.9.5.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.37.1 + Libreria Hugging Face Datasets v2.16.1 + Megatron-core 0.5.0 + EFA v1.30.0 + NCCL v2.19.4 ## La libreria di SageMaker parallelismo dei modelli v2.2.0 *Data: 7 marzo 2024* **Nuove funzionalità** + È stato aggiunto il supporto per l'[FP8 addestramento](model-parallel-core-features-v2-mixed-precision.md#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5) dei seguenti modelli di trasformatori Hugging Face su istanze P5 con integrazione Transformer Engine: + GPT-NeoX + Llama 2 **Correzioni di bug** + Risoluzione di un bug per cui non era garantito che i tensori fossero contigui prima della chiamata collettiva `AllGather` durante l’addestramento per la parallelizzazione tensoriale. **Aggiornamenti valutari** + È stato aggiunto il supporto per la PyTorch versione 2.2.0. + Libreria SMDDP aggiornata alla v2.2.0. + È stata aggiornata la FlashAttention libreria alla v2.3.3. + Libreria NCCL aggiornata alla v2.19.4. **Raggiunta obsolescenza** + Interruzione del supporto per le versioni di Transformer Engine precedenti alla v1.2.0. **Problemi noti** + La funzionalità [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md) di SMP al momento non funziona. Utilizzate invece l'offload di PyTorch attivazione nativo. **Altre modifiche** + È stata inclusa una patch per correggere la regressione delle prestazioni discussa nel thread del problema all'indirizzo [https://github.com/pytorch/pytorch/issues/117748](https://github.com/pytorch/pytorch/issues/117748) nel repository. PyTorch GitHub **Container Docker di SMP** Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se utilizzi la classe PyTorch estimator in SageMaker Python SDK e specifichi la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK alla versione 2.212.0 o successiva. + Contenitore SMP Docker per v2.2.0 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` + Disponibile per istanze P4d, P4de e P5 + Pacchetti preinstallati in questo container Docker + Libreria SMDDP v2.2.0 + CUDNN v8.9.5.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.37.1 + Libreria Hugging Face Datasets v2.16.1 + EFA v1.30.0 + NCCL v2.19.4 ## La libreria di SageMaker parallelismo dei modelli v2.1.0 *Data: 6 febbraio 2024* **Aggiornamenti valutari** + È stato aggiunto il supporto per la PyTorch versione 2.1.2. **Raggiunta obsolescenza** + Interruzione del supporto per Hugging Face Transformers v4.31.0. **Problemi noti** + Rilevamento di un problema in cui il fine-tuning di Hugging Face Llama 2 con `attn_implementation=flash_attention_2` e FSDP causa la divergenza del modello. Per riferimento, consulta il [ticket di emissione nel repository](https://github.com/huggingface/transformers/issues/28826) *Hugging* Face Transformers. GitHub Per evitare il problema della divergenza, utilizza `attn_implementation=sdpa`. In alternativa, utilizza l’implementazione del modello di trasformatore SMP configurando `use_smp_implementation=True`. **Container Docker di SMP** Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se si utilizza la classe PyTorch estimator in SageMaker Python SDK e si specifica la configurazione di distribuzione per utilizzare SMP v2 SageMaker , preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK alla versione 2.207.0 o successiva. + Contenitore SMP Docker per v2.1.2 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 ``` + Disponibile per istanze P4d, P4de e P5 + Pacchetti preinstallati in questo container Docker + Libreria SMDDP v2.1.0 + CUDNN v8.9.5.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.37.1 + Libreria Hugging Face Datasets v2.16.1 + EFA v1.30.0 **Canale Conda di SMP** Il seguente bucket S3 è un canale Conda pubblico ospitato dal team di assistenza SMP. Se desideri installare la libreria SMP v2 in un ambiente di risorse di calcolo altamente personalizzabili come SageMaker HyperPod i cluster, usa questo canale Conda per installare correttamente la libreria SMP. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Per ulteriori informazioni sui canali Conda in generale, consulta [Canali](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) nella *documentazione di Conda*. ## La libreria di parallelismo dei modelli v2.0.0 SageMaker *Data: 19 dicembre 2023* **Nuove funzionalità** È stata rilasciata la libreria SageMaker Model Parallelism (SMP) v2.0.0 con le seguenti nuove offerte. + Un pacchetto `torch.sagemaker` completamente rinnovato rispetto al pacchetto `smdistributed.modelparallel.torch` precedente di SMP v1.x. + Support per PyTorch 2.0.1. + Support per PyTorch FSDP. + Implementazione della parallelizzazione tensoriale mediante integrazione con la libreria [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html). + Support sia per la [SageMaker formazione](train-model.md) che per [SageMaker HyperPod](sagemaker-hyperpod.md). **Modifiche rivoluzionarie** + SMP v2 ha APIs completamente rinnovato e fornisce il pacchetto. `torch.sagemaker` In generale, è sufficiente eseguire l’inizializzazione con il modulo `torch.sagemaker.init()` e passare i parametri di configurazione della parallelizzazione dei modelli. Questo nuovo pacchetto consente di semplificare significativamente le modifiche al codice nello script di addestramento. Per ulteriori informazioni sull’adattamento dello script di addestramento per utilizzare SMP v2, consulta [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md). + Se hai addestrato i modelli Hugging Face Transformer con SMP v1 e desideri riutilizzarli in SMP v2, consulta [Aggiornamento da SMP v1 a SMP v2](distributed-model-parallel-v2-reference.md#model-parallel-v2-upgrade-from-v1). + Per la formazione PyTorch su FSDP, è necessario utilizzare SMP v2. **Problemi noti** + Attualmente, il checkpoint di attivazione funziona solo con le policy di wrapping con FSDP indicate di seguito. + `auto_wrap_policy = functools.partial(transformer_auto_wrap_policy, ...)` + Per utilizzare [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md), il tipo di checkpoint di attivazione FSDP deve essere [REENTRANT](https://pytorch.org/docs/stable/checkpoint.html). + Durante l’esecuzione con la parallelizzazione dei tensori abilitata con il grado parallelo dei dati sottoposti a sharding impostato su `1`, è necessario utilizzare `backend = nccl`. In questo scenario, l’opzione di backend `smddp` non è supportata. + [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) deve essere utilizzato PyTorch con la libreria SMP anche quando non si utilizza il parallelismo tensoriale. **Altre modifiche** + A partire da questa versione, la documentazione per la libreria di parallelismo dei SageMaker modelli è completamente disponibile in questa *Amazon SageMaker AI Developer Guide*. A favore di questa guida completa per gli sviluppatori per SMP v2 nella *Amazon SageMaker AI Developer Guide*, il [riferimento aggiuntivo per SMP v1.x](https://sagemaker.readthedocs.io/en/stable/api/training/distributed.html#the-sagemaker-distributed-model-parallel-library) nella documentazione di *SageMaker Python* SDK è obsoleto. [Se hai ancora bisogno della documentazione per SMP v1.x, la guida per sviluppatori per SMP v1.x è disponibile all'indirizzo [(Archiviata) Libreria SageMaker Model Parallelism v1.x](model-parallel.md) e il riferimento alla libreria SMP Python v1.x è disponibile nella documentazione di Python SDK v2.199.0. SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) **Deprecazioni** + Supporto interrotto per. TensorFlow + In SMP v2 non è previsto il supporto per la parallelizzazione delle pipeline. + Non è disponibile alcun supporto per la DeepSpeed libreria a favore del formato PyTorch FSDP nativo. **Container Docker di SMP** Il team della libreria SMP distribuisce i contenitori Docker in sostituzione dei contenitori del framework. SageMaker PyTorch Se utilizzi la classe PyTorch estimator in SageMaker Python SDK e specifichi la configurazione di distribuzione per utilizzare SMP v2 SageMaker , AI preleva automaticamente i contenitori SMP Docker. Per utilizzare questa versione di SMP v2, aggiorna il tuo SageMaker Python SDK alla versione 2.207.0 o successiva. + Contenitore SMP Docker per v2.0.1 con CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.0.1-gpu-py310-cu121 ``` # (Archiviata) Libreria SageMaker Model Parallelism v1.x **Importante** A partire dal 19 dicembre 2023, viene rilasciata la libreria SageMaker Model Parallelism (SMP) v2. Le funzionalità di SMP v1 non saranno più supportate nelle versioni future a favore della libreria SMP v2. La sezione e gli argomenti seguenti sono archiviati e riguardano specificamente l’uso della libreria SMP v1. Per informazioni su come utilizzare la libreria SMP v2, consulta [Libreria SageMaker Model Parallelism v2](model-parallel-v2.md). Utilizza la libreria parallela di modelli di Amazon SageMaker AI per addestrare modelli di deep learning (DL) di grandi dimensioni che sono difficili da addestrare a causa delle limitazioni di memoria della GPU. La libreria suddivide automaticamente ed efficacemente un modello su più GPU e istanze. Utilizzando la libreria, puoi raggiungere più rapidamente l'obiettivo di precisione di previsione addestrando in modo efficiente modelli DL più grandi con miliardi o trilioni di parametri. Puoi utilizzare la libreria per partizionare automaticamente i tuoi modelli TensorFlow e PyTorch su più GPU e più nodi con modifiche minime al codice. Puoi accedere all'API della libreria tramite SageMaker Python SDK. Utilizza le seguenti sezioni per saperne di più sul parallelismo dei modelli e sulla libreria parallela di modelli SageMaker. La documentazione API di questa libreria è disponibile nella sezione [API di addestramento distribuito](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) della *documentazione di SageMaker Python SDK v2.199.0*. **Topics** + [Introduzione al parallelismo dei modelli](model-parallel-intro.md) + [Framework supportati e Regioni AWS](distributed-model-parallel-support.md) + [Caratteristiche principali della SageMaker Model Parallelism Library](model-parallel-core-features.md) + [Esegui un job di formazione SageMaker distribuito con Model Parallelism](model-parallel-use-api.md) + [Checkpoint e ottimizzazione di un modello con il parallelismo dei modelli](distributed-model-parallel-checkpointing-and-finetuning.md) + [Esempi della libreria di parallelismo dei modelli Amazon SageMaker AI v1](distributed-model-parallel-examples.md) + [SageMaker Best practice per il parallelismo dei modelli distribuiti](model-parallel-best-practices.md) + [Suggerimenti e insidie per la configurazione della SageMaker Distributed Model Parallelism Library](model-parallel-customize-tips-pitfalls.md) + [Risoluzione dei problemi del parallelismo dei modelli](distributed-troubleshooting-model-parallel.md) # Introduzione al parallelismo dei modelli Il parallelismo dei modelli è un metodo di addestramento distribuito in cui il modello di deep learning è partizionato su più dispositivi, all'interno o tra istanze. Questa pagina introduttiva fornisce una panoramica di alto livello sul parallelismo dei modelli, una descrizione di come può aiutare a superare i problemi che sorgono durante l'addestramento di modelli DL che in genere sono di dimensioni molto grandi ed esempi di ciò che offre la libreria SageMaker parallela del modello per aiutare a gestire le strategie parallele dei modelli e il consumo di memoria. ## Che cos'è il parallelismo dei modelli? L'aumento delle dimensioni dei modelli di deep learning (livelli e parametri) consente di ottenere una maggiore precisione per attività complesse come la visione artificiale e l'elaborazione del linguaggio naturale. Tuttavia, esiste un limite alla dimensione massima del modello che è possibile inserire nella memoria di una singola GPU. Durante l'addestramento dei modelli DL, le limitazioni della memoria della GPU possono rappresentare un ostacolo nei seguenti modi: + Limitano le dimensioni del modello che è possibile addestrare, poiché l'ingombro di memoria di un modello si ridimensiona proporzionalmente al numero di parametri. + Limitano la dimensione del batch per GPU durante l'addestramento, riducendo l'utilizzo della GPU e l'efficienza dell'addestramento. Per superare i limiti associati all'addestramento di un modello su una singola GPU, SageMaker fornisce la libreria model parallel per aiutare a distribuire e addestrare i modelli DL in modo efficiente su più nodi di calcolo. Inoltre, con la libreria, è possibile ottenere un addestramento distribuito più ottimizzato utilizzando dispositivi supportati da EFA, che migliorano le prestazioni della comunicazione tra i nodi con bassa latenza, throughput elevato e bypass del sistema operativo. ## Stima dei requisiti di memoria prima di utilizzare il parallelismo dei modelli Prima di utilizzare la libreria SageMaker model parallel, considerate quanto segue per avere un'idea dei requisiti di memoria necessari per addestrare modelli DL di grandi dimensioni. Per un processo di formazione che utilizza gli ottimizzatori AMP (FP16) e Adam, la memoria GPU richiesta per parametro è di circa 20 byte, che possiamo suddividere come segue: + Un FP16 parametro \$1 2 byte + Un FP16 gradiente \$1 2 byte + Uno stato di FP32 ottimizzazione di \$1 8 byte basato sugli ottimizzatori Adam + Una FP32 copia del parametro \$1 4 byte (necessaria per il funzionamento (OA`optimizer apply`)) + Una FP32 copia di gradient \$1 4 byte (necessaria per il funzionamento OA) Anche per un modello DL relativamente piccolo con 10 miliardi di parametri, possono essere necessari almeno 200 GB di memoria, che è una dimensione molto più grande della tipica memoria GPU (ad esempio, NVIDIA A100 con 40 GB/80 GB di memoria e V100 con 16/32 GB) disponibile su una singola GPU. Tieni presente che oltre ai requisiti di memoria per gli stati del modello e dell'ottimizzatore, ci sono altri utenti di memoria, come le attivazioni generate nel forward pass. La memoria richiesta può essere molto superiore a 200 GB. Per la formazione distribuita, ti consigliamo di utilizzare istanze Amazon EC2 P3 e P4 con NVIDIA V100 e A100 Tensor Core rispettivamente. GPUs Per ulteriori dettagli sulle specifiche quali core della CPU, RAM, volume di archiviazione collegato e larghezza di banda della rete, consulta la sezione *Elaborazione accelerata* nella pagina [Tipi di istanze Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Anche con le istanze a calcolo accelerato, è ovvio che i modelli con circa 10 miliardi di parametri come Megatron-LM e T5 e i modelli ancora più grandi con centinaia di miliardi di parametri come GPT-3 non possono contenere repliche di modelli in ogni dispositivo GPU. ## In che modo la libreria utilizza il parallelismo dei modelli e le tecniche di risparmio della memoria La libreria comprende vari tipi di funzionalità di parallelismo dei modelli e funzionalità di risparmio di memoria come il partizionamento dello stato dell'ottimizzatore, il checkpoint di attivazione e l'offload dell'attivazione. Tutte queste tecniche possono essere combinate per addestrare in modo efficiente modelli di grandi dimensioni composti da centinaia di miliardi di parametri. **Topics** + [Parallelismo dei dati condiviso (disponibile per) PyTorch](#model-parallel-intro-sdp) + [PyTorch TensorFlowParallelismo delle pipeline (disponibile per e)](#model-parallel-intro-pp) + [Parallelismo tensoriale (disponibile per) PyTorch](#model-parallel-intro-tp) + [Condivisione dello stato dell'ottimizzatore (disponibile per) PyTorch](#model-parallel-intro-oss) + [Attivazione, offload e checkpointing (disponibile per) PyTorch](#model-parallel-intro-activation-offloading-checkpointing) + [Scelta delle tecniche giuste per il modello](#model-parallel-intro-choosing-techniques) ### Parallelismo dei dati condiviso (disponibile per) PyTorch 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) all'interno di un gruppo parallelo di dati. GPUs SageMaker ****[L'intelligenza artificiale implementa il parallelismo dei dati condivisi attraverso l'implementazione di MIC, una libreria che minimizza la comunicazione su larga scala e discussa nel post del blog Near-linear scaling of **gigantic-model** training on. AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws)**** Puoi applicare la parallelizzazione dei dati sottoposti a sharding al modello come strategia standalone. Inoltre, se utilizzi le istanze GPU più performanti dotate di NVIDIA A100 Tensor Core GPUs`ml.p4d.24xlarge`, puoi sfruttare la maggiore velocità di formazione offerta dalle `AllGather` operazioni offerte da SMDDP Collectives. Per approfondire il parallelismo dei dati condivisi e imparare a configurarlo o utilizzare una combinazione del parallelismo dei dati condivisi con altre tecniche come il parallelismo tensoriale e l'addestramento, consulta. FP16 [Parallelismo dei dati partizionati](model-parallel-extended-features-pytorch-sharded-data-parallelism.md) ### PyTorch TensorFlowParallelismo delle pipeline (disponibile per e) Il *parallelismo della pipeline* partiziona l'insieme di livelli o operazioni sull'insieme di dispositivi, lasciando intatta ogni operazione. Quando specificate un valore per il numero di partizioni del modello (`pipeline_parallel_degree`), il numero totale di GPUs (`processes_per_host`) deve essere divisibile per il numero delle partizioni del modello. Per configurarlo correttamente, devi specificare i valori corretti per i parametri `pipeline_parallel_degree` e `processes_per_host`. Il semplice calcolo è il seguente: ``` (pipeline_parallel_degree) x (data_parallel_degree) = processes_per_host ``` La libreria si occupa di calcolare il numero di repliche del modello (chiamate anche `data_parallel_degree`) in base ai due parametri di input forniti. Ad esempio, se impostate `"pipeline_parallel_degree": 2` e `"processes_per_host": 8` utilizzate un'istanza ML con otto GPU worker, ad esempio`ml.p3.16xlarge`, la libreria configura automaticamente il modello distribuito attraverso il parallelismo dei dati a quattro vie GPUs . L'immagine seguente illustra come un modello viene distribuito tra gli otto sistemi, GPUs ottenendo un parallelismo dei dati a quattro vie e un parallelismo di pipeline bidirezionale. Ogni replica del modello, dove la definiamo come un *gruppo parallelo di pipeline* e la etichettiamo come`PP_GROUP`, è partizionata su due. GPUs Ogni partizione del modello è assegnata a quattro GPUs, dove le quattro repliche di partizione si trovano in un *gruppo parallelo* di dati e sono etichettate come. `DP_GROUP` Senza il parallelismo tensoriale, il gruppo parallelo della pipeline è essenzialmente il gruppo parallelo del modello. ![\[Come viene distribuito un modello tra gli otto, GPUs ottenendo il parallelismo dei dati a quattro vie e il parallelismo delle pipeline a due vie.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-pipeline-parallel-only.png) Per approfondire la parallelizzazione delle pipeline, consulta [Caratteristiche principali della SageMaker Model Parallelism Library](model-parallel-core-features.md). Per iniziare a eseguire il modello utilizzando il parallelismo della pipeline, consulta [Run a Distributed SageMaker Training Job with the SageMaker Model](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html) Parallel Library. ### Parallelismo tensoriale (disponibile per) PyTorch Il *parallelismo tensoriale* divide i singoli livelli, o `nn.Modules`, tra dispositivi, per essere eseguiti in parallelo. La figura seguente mostra l'esempio più semplice di come la libreria divide un modello con quattro livelli per ottenere un parallelismo tensoriale bidirezionale (`"tensor_parallel_degree": 2`). Gli strati di ogni replica del modello sono divisi in due e distribuiti in due. GPUs In questo caso di esempio, la configurazione parallela del modello include anche `"pipeline_parallel_degree": 1` e `"ddp": True` (utilizza il PyTorch DistributedDataParallel pacchetto in background), quindi il grado di parallelismo dei dati diventa otto. La libreria gestisce la comunicazione tra le repliche del modello distribuite dai tensori. ![\[L’esempio più semplice di come la libreria divide un modello con quattro livelli per ottenere una parallelizzazione dei tensori bidirezionale ("tensor_parallel_degree": 2).\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-tensor-parallel-only.png) L'utilità di questa funzionalità sta nel fatto che è possibile selezionare livelli specifici o un sottoinsieme di livelli per applicare il parallelismo tensoriale. Per approfondire il parallelismo tensoriale e altre funzionalità di risparmio di memoria e per imparare a impostare una combinazione di parallelismo tensoriale e di pipeline PyTorch, vedi. [Parallelismo tensoriale](model-parallel-extended-features-pytorch-tensor-parallelism.md) ### Condivisione dello stato dell'ottimizzatore (disponibile per) PyTorch Per capire come la libreria esegue il *partizionamento dello stato dell'ottimizzatore*, prendi in considerazione un semplice modello di esempio con quattro livelli. L'idea chiave nell'ottimizzazione dello state sharding è che non è necessario replicare lo stato dell'ottimizzatore in tutti i tuoi. GPUs Piuttosto, una singola replica dello stato dell'ottimizzatore viene suddivisa tra classificazioni parallele ai dati, senza ridondanza tra i dispositivi. Ad esempio, la GPU 0 contiene lo stato dell'ottimizzatore per il primo livello, la GPU 1 successiva contiene lo stato dell'ottimizzatore per L2 e così via. La seguente figura animata mostra una propagazione all'indietro con la tecnica di partizionamento dello stato dell'ottimizzatore. Al termine della propagazione all'indietro, è previsto il tempo di calcolo e di rete necessario all'operazione `optimizer apply` (OA) per aggiornare gli stati dell'ottimizzatore e all'operazione `all-gather` (AG) per aggiornare i parametri del modello per l'iterazione successiva. Soprattutto, l'operazione `reduce` può sovrapporsi al calcolo sulla GPU 0, ottenendo una propagazione all'indietro più efficiente in termini di memoria e più rapida. Nell'attuale implementazione, le operazioni AG e OA non si sovrappongono a `compute`. Può comportare un calcolo esteso durante l'operazione AG, quindi potrebbe esserci un compromesso. ![\[Una propagazione all’indietro con la tecnica di sharding dello stato dell’ottimizzatore.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-optimizer-state-sharding.gif) Per ulteriori informazioni su come utilizzare questa funzionalità, consulta [Optimizer State Sharding](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-optimizer-state-sharding.html). ### Attivazione, offload e checkpointing (disponibile per) PyTorch Per risparmiare memoria della GPU, la libreria supporta il checkpoint di attivazione per evitare di memorizzare le attivazioni interne nella memoria della GPU per i moduli specificati dall'utente durante il passaggio in avanti. La libreria ricalcola queste attivazioni durante il passaggio all'indietro. Inoltre, la funzione di offload dell'attivazione scarica le attivazioni memorizzate nella memoria della CPU e le recupera sulla GPU durante il passaggio all'indietro per ridurre ulteriormente l'ingombro della memoria di attivazione. Per ulteriori informazioni su come utilizzare queste funzionalità, consulta [Activation Checkpoint](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-checkpointing.html) e [Activation Offloading](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-offloading.html). ### Scelta delle tecniche giuste per il modello Per ulteriori informazioni sulla scelta delle tecniche e delle configurazioni corrette, consulta [SageMaker Distributed Model Parallel Best Practice](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-best-practices.html) e Suggerimenti e insidie per la [configurazione](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-customize-tips-pitfalls.html). # Framework supportati e Regioni AWS Prima di utilizzare la libreria di parallelismo dei SageMaker modelli, controlla i framework e i tipi di istanza supportati e determina se ci sono quote sufficienti nel tuo account e. AWS Regione AWS **Nota** Per controllare gli ultimi aggiornamenti e le note di rilascio della libreria, consulta le [SageMaker Model Parallel Release Notes](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) nella documentazione di *SageMaker Python SDK*. ## Framework supportati La libreria di parallelismo dei SageMaker modelli supporta i seguenti framework di deep learning ed è disponibile in AWS Deep Learning Containers (DLC) o scaricabile come file binario. PyTorch versioni supportate dall'IA e dalla libreria di parallelismo dei modelli SageMaker SageMaker | PyTorch versione | SageMaker versione della libreria di parallelismo dei modelli | URI dell’immagine del container DLC integrata `smdistributed-modelparallel` | URL del file binario\$1\$1 | | --- | --- | --- | --- | | v2.0.0 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-2.0.0/build-artifacts/2023-04-14-20-14/smdistributed\$1modelparallel-1.15.0-cp310-cp310-linux\$1x86\$164.whl | | v1.13.1 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.13.1/build-artifacts/2023-04-17-15-49/smdistributed\$1modelparallel-1.15.0-cp39-cp39-linux\$1x86\$164.whl | | v1.12.1 | smdistributed-modelparallel==v1.13.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.1/build-artifacts/2022-12-08-21-34/smdistributed\$1modelparallel-1.13.0-cp38-cp38-linux\$1x86\$164.whl | | v1.12.0 | smdistributed-modelparallel==v1.11.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.0/build-artifacts/2022-08-12-16-58/smdistributed\$1modelparallel-1.11.0-cp38-cp38-linux\$1x86\$164.whl | | v1.11.0 | smdistributed-modelparallel==v1.10.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.11.0/build-artifacts/2022-07-11-19-23/smdistributed\$1modelparallel-1.10.0-cp38-cp38-linux\$1x86\$164.whl | | v1.10.2 | smdistributed-modelparallel==v1.7.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.2-gpu-py38-cu113-ubuntu20.04-sagemaker` | - | | v1.10.0 | smdistributed-modelparallel==v1.5.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | - | | v1.9.1 | smdistributed-modelparallel==v1.4.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.9.1-gpu-py38-cu111-ubuntu20.04` | - | | v1.8.1\$1 | smdistributed-modelparallel==v1.6.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.8.1-gpu-py36-cu111-ubuntu18.04` | - | **Nota** La libreria di parallelismo dei modelli v1.6.0 e successive fornisce funzionalità estese per. SageMaker PyTorch Per ulteriori informazioni, consulta [Caratteristiche principali della SageMaker Model Parallelism Library](model-parallel-core-features.md). \$1\$1 I file binari servono per l'installazione URLs della libreria di parallelismo del SageMaker modello in contenitori personalizzati. Per ulteriori informazioni, consulta [Crea il tuo contenitore Docker con la Distributed Model Parallel Library SageMaker](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container). TensorFlow versioni supportate dall' SageMaker IA e dalla libreria di SageMaker parallelismo dei modelli | TensorFlow versione | SageMaker versione della libreria di parallelismo dei modelli | URI dell’immagine del container DLC integrata `smdistributed-modelparallel` | | --- | --- | --- | | v2.6.0 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.6.0-gpu-py38-cu112-ubuntu20.04 | | v2.5.1 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.5.1-gpu-py37-cu112-ubuntu18.04 | **Versioni di Hugging Face Transformers supportate dall'IA SageMaker e dalla libreria parallela di dati distribuiti SageMaker** I AWS Deep Learning Containers for Hugging Face utilizzano i SageMaker Training Containers per PyTorch e TensorFlow come immagini di base. [Per cercare le versioni della libreria Hugging Face Transformers e le versioni abbinate, TensorFlow consulta gli ultimi Hugging Face Containers PyTorch e le versioni precedenti di Hugging [Face](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) Container.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#prior-hugging-face-container-versions) ## Regioni AWS La libreria parallela di SageMaker dati è disponibile in tutti i paesi in Regioni AWS cui SageMaker sono in servizio i [AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only). Per ulteriori informazioni, consulta [Immagini dei container di deep learning disponibili](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#available-deep-learning-containers-images). ## Tipi di istanze supportati La libreria di parallelismo dei SageMaker modelli richiede uno dei seguenti tipi di istanze ML. | Tipo di istanza | | --- | | ml.g4dn.12xlarge | | ml.p3.16xlarge | | ml.p3dn.24xlarge | | ml.p4d.24xlarge | | ml.p4de.24xlarge | Per le specifiche dei tipi di istanza, consulta la sezione **Elaborazione accelerata** nella [pagina tipi di istanza Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Per informazioni sui prezzi delle istanze, consulta la pagina [dei prezzi di Amazon SageMaker AI](https://aws.amazon.com/sagemaker/pricing/). Se hai riscontrato un messaggio di errore simile al seguente, segui le istruzioni in [Richiedi un aumento della quota di servizio per le risorse SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure). ``` ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling the CreateTrainingJob operation: The account-level service limit 'ml.p3dn.24xlarge for training job usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please contact AWS support to request an increase for this limit. ``` # Caratteristiche principali della SageMaker Model Parallelism Library La libreria di parallelismo dei modelli di Amazon SageMaker AI offre strategie di distribuzione e tecniche di risparmio di memoria, come il parallelismo dei dati condivisi, il parallelismo tensoriale, il partizionamento dei modelli per livelli per la pianificazione delle pipeline e il checkpoint. Le strategie e le tecniche di parallelismo dei modelli aiutano a distribuire modelli di grandi dimensioni su più dispositivi, ottimizzando al contempo la velocità di addestramento e il consumo di memoria. La libreria fornisce anche funzioni di supporto in Python, gestori di contesto e funzioni wrapper per adattare lo script di addestramento per il partizionamento automatico o manuale del modello. Quando implementi il parallelismo dei modelli nel tuo processo di formazione, mantieni lo stesso flusso di lavoro in due fasi mostrato nella sezione [Esegui un processo di SageMaker formazione distribuito con parallelismo del modello](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html). Per adattare lo script di addestramento, aggiungerete zero o poche righe di codice aggiuntive allo script di addestramento. Per avviare un processo di addestramento dello script di addestramento adattato, è necessario impostare i parametri di configurazione della distribuzione per attivare le funzioni di risparmio di memoria o per trasmettere i valori relativi al grado di parallelismo. Per iniziare con degli esempi, consultate i seguenti notebook Jupyter che dimostrano come utilizzare la libreria di parallelismo dei modelli. SageMaker + [PyTorch quaderni di esempio](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel) + [TensorFlow quaderni di esempio](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/tensorflow/model_parallel/mnist) Per approfondire le caratteristiche principali della libreria, consulta i seguenti argomenti. **Nota** Le librerie di formazione SageMaker distribuite sono disponibili tramite i contenitori di AWS deep learning per PyTorch Hugging Face e TensorFlow all'interno della piattaforma Training. SageMaker Per utilizzare le funzionalità delle librerie di formazione distribuite, ti consigliamo di utilizzare SageMaker Python SDK. Puoi anche configurare manualmente la sintassi della richiesta JSON se la utilizzi SageMaker APIs tramite SDK for Python (Boto3) o. AWS Command Line Interface In tutta la documentazione, le istruzioni e gli esempi si concentrano su come utilizzare le librerie di formazione distribuite con SageMaker Python SDK. **Importante** La libreria di parallelismo dei SageMaker modelli supporta tutte le funzionalità principali e supporta il parallelismo delle PyTorch pipeline per. TensorFlow **Topics** + [Parallelismo dei dati partizionati](model-parallel-extended-features-pytorch-sharded-data-parallelism.md) + [Pipeline di un modello](model-parallel-core-features-pipieline-parallelism.md) + [Parallelismo tensoriale](model-parallel-extended-features-pytorch-tensor-parallelism.md) + [Partizione dello stato dell'ottimizzatore](model-parallel-extended-features-pytorch-optimizer-state-sharding.md) + [Checkpoint di attivazione](model-parallel-extended-features-pytorch-activation-checkpointing.md) + [Offload di attivazione](model-parallel-extended-features-pytorch-activation-offloading.md) + [FP16 Formazione con Model Parallelism](model-parallel-extended-features-pytorch-fp16.md) + [Support per FlashAttention](model-parallel-attention-head-size-for-flash-attention.md) # 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 **Nota** Il parallelismo dei dati suddivisi è disponibile nella libreria di parallelismo dei modelli v1.11.0 e versioni successive. PyTorch SageMaker Quando si ridimensiona il processo di formazione su un cluster di GPU di grandi dimensioni, è possibile ridurre l'ingombro di memoria per GPU del modello suddividendo lo stato di addestramento del modello su più livelli. GPUs Ciò offre due vantaggi: è possibile utilizzare modelli più grandi, che altrimenti esaurirebbero la memoria con il parallelismo dei dati standard, oppure è possibile aumentare la dimensione del batch utilizzando la memoria della GPU liberata. 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](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) 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, MiCS partiziona nuovamente i parametri per risparmiare memoria della 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 in 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 partizionati introduce un compromesso tra il sovraccarico delle comunicazioni e l'efficienza della memoria della GPU. L'uso del parallelismo dei dati partizionati aumenta i costi della comunicazione, ma l'ingombro della memoria della GPU (escluso l'utilizzo della memoria dovuto alle attivazioni) viene suddiviso per il grado di parallelismo dei dati partizionati, quindi è possibile inserire modelli più grandi nel cluster della 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 partizionati, assicurati di trovare la configurazione di addestramento più ottimale che possa essere eseguito 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 (OOM). out-of-memory Se riscontri l'errore OOM anche con la dimensione del batch più piccola, applica un grado più elevato di parallelismo dei dati partizionati o una combinazione di parallelismo dei dati partizionati e parallelismo tensoriale. **Topics** + [Come applicare il parallelismo dei dati partizionati al tuo processo di addestramento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use) + [Configurazioni di riferimento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use-config-sample) + [Parallelismo dei dati partizionati con i collettivi SMDDP](#model-parallel-extended-features-pytorch-sharded-data-parallelism-smddp-collectives) + [Addestramento misto di precisione con parallelismo di dati partizionati](#model-parallel-extended-features-pytorch-sharded-data-parallelism-16bits-training) + [Parallelismo dei dati partizionati con parallelismo tensoriale](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism) + [Suggerimenti e considerazioni per l'utilizzo del parallelismo dei dati partizionati](#model-parallel-extended-features-pytorch-sharded-data-parallelism-considerations) ## 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 SageMaker PyTorch parametri. 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](model-parallel-customize-training-script-pt.md) 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 consentire a SMP di raccogliere i parametri completi. 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 stimatore SageMaker PyTorch Quando configuri uno SageMaker PyTorch stimatore[Fase 2: Avviare un job di formazione utilizzando SageMaker Python SDK](model-parallel-sm-sdk.md), 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. + `"sdp_reduce_bucket_size"`*(int, default: 5e8)* — Specifica la dimensione dei [bucket di gradiente PyTorch DDP](https://pytorch.org/docs/stable/notes/ddp.html#internal-design) in numero di elementi del dtype predefinito. + `"sdp_param_persistence_threshold"`*(int, default: 1e6)*: specifica la dimensione di un tensore di parametri in numero di elementi che possono persistere in ogni GPU. Il parallelismo dei dati condivisi divide ogni tensore di parametri in un gruppo parallelo di GPUs dati. Se il numero di elementi nel tensore dei parametri è inferiore a questa soglia, il tensore del parametro non viene suddiviso; ciò aiuta a ridurre il sovraccarico di comunicazione perché il tensore del parametro viene replicato su dati paralleli. GPUs + `"sdp_max_live_parameters"`*(int, default: 1e9)*: specifica il numero massimo di parametri che possono trovarsi contemporaneamente in uno stato di addestramento ricombinato durante il passaggio in avanti e all'indietro. Il recupero dei parametri con l'operazione `AllGather` si interrompe quando il numero di parametri attivi raggiunge la soglia specificata. Si noti che l'aumento di questo parametro aumenta l'ingombro di memoria. + `"sdp_hierarchical_allgather"`*(bool, default: True)*: se impostato su `True`, l'operazione `AllGather`viene eseguita in modo gerarchico: viene eseguita prima all'interno di ogni nodo e poi tra i nodi. Per i processi di addestramento distribuito su più nodi, l'operazione `AllGather` gerarchica viene attivata automaticamente. + `"sdp_gradient_clipping"`*(float, default: 1.0)*: specifica una soglia per il ritaglio del gradiente secondo la norma L2 dei gradienti prima di propagarli all'indietro attraverso i parametri del modello. Quando è attivato il parallelismo dei dati partizionati, viene attivato anche il ritaglio del gradiente. La soglia predefinita è `1.0`. Regola questo parametro se hai il problema dei gradienti esplosivi. 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. Puoi estrapolare le configurazioni seguenti per sperimentare e stimare l'utilizzo della memoria della GPU per la configurazione del modello. Parallelismo dei dati partizionati con i collettivi SMDDP | Modello/numero di parametri | Numero di istanze | Tipo di istanza | Lunghezza della sequenza | Dimensioni batch globali | Dimensioni del mini-batch | Grado parallelo di dati partizionati | | --- | --- | --- | --- | --- | --- | --- | | GPT-NEOX-20B | 2 | ml.p4d.24xlarge | 2048 | 64 | 4 | 16 | | GPT-NEOX-20B | 8 | ml.p4d.24xlarge | 2048 | 768 | 12 | 32 | 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 partizionati con parallelismo tensoriale e collettivi NCCL | Modello/numero di parametri | Numero di istanze | Tipo di istanza | Lunghezza della sequenza | Dimensioni batch globali | Dimensioni del mini-batch | Grado parallelo di dati partizionati | Grado di parallelo tensoriale | Offload di attivazione | | --- | --- | --- | --- | --- | --- | --- | --- | --- | | GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 2048 | 512 | 8 | 16 | 8 | Y | | GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 4096 | 512 | 2 | 64 | 2 | Y | 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 della GPU per allenarsi con sequenze di testo più lunghe. LLMs Per ulteriori informazioni, consulta [Parallelismo dei dati partizionati con parallelismo tensoriale](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism). 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](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/). ## Parallelismo dei dati partizionati con i collettivi SMDDP La libreria di parallelismo SageMaker dei dati offre primitive di comunicazione collettiva (collettivi SMDDP) ottimizzate per l'infrastruttura. AWS Raggiunge l'ottimizzazione adottando un modello di all-to-all-type comunicazione basato sull'uso di [Elastic Fabric Adapter (](https://aws.amazon.com/hpc/efa/)EFA), che si traduce in collettivi ad alta velocità e meno sensibili alla latenza, scaricando l'elaborazione relativa alla comunicazione sulla CPU e liberando cicli di GPU per il calcolo. Su cluster di grandi dimensioni, i collettivi SMDDP possono offrire miglioramenti nelle prestazioni di addestramento distribuito fino al 40% rispetto 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](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/). **Nota** Il parallelismo dei dati condivisi con SMDDP Collectives è disponibile nella libreria di parallelismo dei SageMaker modelli v1.13.0 e successive e nella libreria di parallelismo dei dati v1.6.0 e successive. SageMaker Vedi anche [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config) per utilizzare il parallelismo dei dati partizionati con i collettivi SMDDP. Nel parallelismo dei dati partizionati, che è una tecnica comunemente usata nell'addestramento distribuito su larga scala, il collettivo `AllGather` viene utilizzato per ricostituire i parametri dei livelli partizionati per i calcoli dei passaggi avanti e indietro, in parallelo al calcolo della GPU. Per i modelli di grandi dimensioni, eseguire l'operazione `AllGather` in modo efficiente è fondamentale per evitare problemi legati alla GPU e rallentare la velocità di addestramento. Quando viene attivato il parallelismo dei dati partizionati, i collettivi SMDDP entrano a far parte di questi collettivi `AllGather` critici in termini di prestazioni, migliorando la produttività dell'addestramento. **Addestramento con i collettivi SMDDP** Quando il processo di addestramento ha attivato il parallelismo dei dati partizionati e soddisfa i requisiti [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config), i collettivi SMDDP vengono attivati automaticamente. Internamente, i collettivi SMDDP ottimizzano il collettivo per renderlo efficiente sull'infrastruttura e ricorrono a NCCL per tutti gli altri collettivi. `AllGather` AWS Inoltre, in configurazioni non supportate, tutti i collettivi, incluso `AllGather`, utilizzano automaticamente il back-end 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 i collettivi SMDDP quando possibile, altrimenti ricorre a NCCL. Per forzare la libreria a utilizzare sempre NCCL, specifica `"nccl"` nel parametro di configurazione `"ddp_dist_backend"`. 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 come impostazione predefinita 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** L'operazione `AllGather` con i collettivi SMDDP viene attivata nei processi di addestramento quando vengono soddisfatti tutti i seguenti requisiti di configurazione. + Il grado di parallelismo dei dati partizionati è maggiore di 1 + `Instance_count` maggiore di 1 + `Instance_type` uguale a `ml.p4d.24xlarge` + SageMaker contenitore di formazione per v1.12.1 o versione successiva PyTorch + La libreria di parallelismo SageMaker dei dati v1.6.0 o successiva + La libreria di SageMaker parallelismo dei modelli v1.13.0 o successiva **Ottimizzazione delle prestazioni e della memoria** I collettivi SMDDP utilizzano memoria GPU aggiuntiva. Esistono due variabili di ambiente per configurare l'utilizzo della memoria della GPU a seconda dei diversi casi d'uso di addestramento del modello. + `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`: durante l'operazione `AllGather` SMDDP, il buffer di input `AllGather` viene copiato in un buffer temporaneo per la comunicazione tra i nodi. La variabile `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` controlla la dimensione (in byte) di questo buffer temporaneo. Se la dimensione del buffer temporaneo è inferiore alla dimensione del buffer di input `AllGather`, il collettivo `AllGather` torna a utilizzare NCCL. + Valore predefinito: 16 \$1 1024 \$1 1024 (16 MB) + Valori accettabili: qualsiasi multiplo di 8192 + `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`: la variabile `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` serve a dimensionare il buffer temporaneo (in byte) per contenere i dati raccolti dalla comunicazione tra i nodi. Se la dimensione di questo buffer temporaneo è inferiore a `1/8 * sharded_data_parallel_degree * AllGather input size`, il collettivo `AllGather` torna a utilizzare NCCL. + Valore predefinito: 128 \$1 1024 \$1 1024 (128 MB) + Valori accettabili: qualsiasi multiplo di 8192 **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 durante l'addestramento si verifica l'errore (OOM). out-of-memory L'elenco seguente illustra alcuni suggerimenti di ottimizzazione per ridurre l'ingombro di memoria della GPU dei collettivi SMDDP, preservando al contempo il miglioramento delle prestazioni che ne derivano. + Ottimizzazione `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` + La dimensione del buffer di input `AllGather` è inferiore per i modelli più piccoli. Pertanto, la dimensione richiesta per `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` può essere inferiore per i modelli con meno parametri. + La dimensione del buffer di `AllGather` input diminuisce all'`sharded_data_parallel_degree`aumentare, poiché il modello viene ulteriormente suddiviso. GPUs Pertanto, la dimensione richiesta per `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` può essere inferiore per processi di addestramento con valori grandi per `sharded_data_parallel_degree`. + Ottimizzazione `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` + La quantità di dati raccolti dalla comunicazione tra nodi è inferiore per i modelli con un minor numero di parametri. Pertanto, la dimensione richiesta per `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` può essere inferiore per tali modelli con un numero inferiore di parametri. Alcuni collettivi potrebbero tornare a utilizzare NCCL; di conseguenza, potresti non ottenere il miglioramento delle prestazioni dai collettivi SMDDP ottimizzati. Se è disponibile memoria GPU aggiuntiva, è possibile valutare la possibilità di aumentare i valori `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` e `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` per trarre vantaggio dall'aumento delle prestazioni. Il codice seguente mostra come configurare le variabili di ambiente aggiungendole `mpi_options` nel parametro di distribuzione dello stimatore. PyTorch ``` 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 la memoria della GPU con numeri in virgola mobile a mezza precisione e parallelismo dei dati frammentati, puoi 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](https://en.wikichip.org/wiki/brain_floating-point_format) distribuitoBF16. **Nota** L'addestramento misto di precisione con parallelismo dei dati condiviso è disponibile nella libreria di parallelismo dei modelli v1.11.0 e versioni successive. SageMaker **Per FP16 la formazione con Sharded Data Parallelism** Per eseguire l' FP16 allenamento 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 [FP16 Formazione con Model Parallelism](model-parallel-extended-features-pytorch-fp16.md). ``` 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. **Nota** Attualmente, la BF16 formazione funziona solo quando è attivato il parallelismo dei dati suddivisi. Per eseguire l' BF16 allenamento 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](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-tensor-parallelism.html) con il parallelismo dei dati partizionati. Quando si addestra un modello di grandi dimensioni con parallelismo dei dati partizionati su un cluster di elaborazione molto grande (in genere 128 nodi o più), anche un batch di piccole dimensioni per GPU si traduce in un batch globale di dimensioni molto grandi. Potrebbe portare a problemi di convergenza o a basse prestazioni di calcolo. La riduzione della dimensione del batch per GPU a volte non è possibile con il solo parallelismo dei dati partizionati, 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 out-of-memory gli errori CUDA e ottenere le migliori prestazioni. Guardate i due casi di esempio seguenti per scoprire come la combinazione del parallelismo tensoriale e del parallelismo dei dati condivisi 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. **Nota** Questa funzionalità è disponibile nella libreria di parallelismo dei modelli v1.15 e supporta la versione 1.13.1. SageMaker PyTorch **Nota** Questa funzionalità è disponibile per i modelli supportati dalla funzionalità di parallelismo tensoriale della libreria. Per trovare l'elenco dei modelli supportati, consulta [Supporto per i modelli Hugging Face Transformer](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-hugging-face.html). Tieni inoltre presente che devi passare `tensor_parallelism=True` all'argomento `smp.model_creation` mentre modifichi lo script di addestramento. *Per saperne di più, consulta lo script di formazione nell'archivio AI Examples. [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793)SageMaker GitHub * ### 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 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 tensoriale su 8 e la dimensione del batch per GPU 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 4 GPUs), un grado di parallelo dei dati frammentati di 4, finendo con un grado di replica di 2. L'assegnazione crea otto gruppi di GPU in base al grado di parallelismo tensoriale 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 parallelizzazione tensoriale.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_tp.jpg) Figura 1: Gruppi di parallelizzazione tensoriale per (nodi, grado di parallelizzazione dei dati sottoposti a sharding, grado di parallelizzazione tensoriale) = (4, 4, 4), dove ogni rettangolo rappresenta una GPU con indici da 0 a 31. Il parallelismo tensoriale GPUs di forma raggruppa da TPG a TPG. 0 7 I gruppi di replica sono (\$1TPG0, TPG4\$1, \$1TPG1, TPG5\$1, \$1TPG2, TPG6\$1 e \$1TPG3, TPG7\$1); ogni coppia di gruppi di replica condivide lo stesso colore, ma presenta un riempimento diverso. ![\[Figura 2: Gruppi di parallelizzazione dei dati sottoposti a sharding.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_sdp.jpg) Figura 2: Gruppi di parallelizzazione dei dati sottoposti a sharding (nodi, grado di parallelizzazione dei dati sottoposti a sharding, grado di parallelizzazione tensoriale) = (4, 4, 4), dove ogni rettangolo rappresenta una GPU con indici da 0 a 31. Il GPUs modulo Sharded Data Parallelism raggruppa da SDPG a SDPG. 0 7 I gruppi di replica sono (\$1SDPG0, SDPG4\$1, \$1SDPG1, SDPG5\$1, \$1SDPG2, SDPG6\$1 e \$1SDPG3, SDPG7\$1); ogni coppia di gruppi di replica condivide lo stesso colore, ma presenta un riempimento diverso. ### Come attivare il parallelismo dei dati partizionati con il parallelismo tensoriale Per utilizzare il parallelismo dei dati condivisi 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 leggere 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 dati`smp.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, consulta [Prescaled Batch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#prescaled-batch) nella documentazione di *SageMaker Python* SDK. *Vedi anche lo script di addestramento di esempio [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164)per 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](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism-ex2) ``` 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. + Il parallelismo dei dati condivisi è compatibile con la formazione. FP16 Per eseguire l' FP16allenamento, consulta la sezione. [FP16 Formazione con Model Parallelism](model-parallel-extended-features-pytorch-fp16.md) + Il parallelismo dei dati partizionati è compatibile con il parallelismo tensoriale. I seguenti elementi sono ciò che potresti dover considerare per utilizzare il parallelismo dei dati partizionati con il parallelismo tensoriale. + Quando si utilizza il parallelismo dei dati partizionati con il parallelismo tensoriale, anche i livelli di incorporamento vengono distribuiti automaticamente nel gruppo parallelo tensoriale. In altre parole, il parametro `distribute_embedding` viene impostato automaticamente su `True`. Per maggiori informazioni sul parallelismo tensoriale, consulta [Parallelismo tensoriale](model-parallel-extended-features-pytorch-tensor-parallelism.md). + Si noti che il parallelismo dei dati partizionati con il parallelismo tensoriale attualmente utilizza i collettivi NCCL come back-end della strategia di addestramento distribuito. Per ulteriori informazioni, consulta la sezione [Parallelismo dei dati partizionati con parallelismo tensoriale](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism). + Il parallelismo dei dati partizionati attualmente non è compatibile con il [parallelismo di pipeline](model-parallel-intro.md#model-parallel-intro-pp) o il [partizionamento dello stato dell'ottimizzatore](model-parallel-extended-features-pytorch-optimizer-state-sharding.md). Per attivare il parallelismo dei dati partizionati, disattiva il partizionamento dello stato dell'ottimizzatore e imposta il grado di parallelismo della pipeline su 1. + Le funzionalità [checkpoint di attivazione](model-parallel-extended-features-pytorch-activation-checkpointing.md) e [offload di attivazione](model-parallel-extended-features-pytorch-activation-offloading.md) sono compatibili con il parallelismo dei dati partizionati. + Per utilizzare il parallelismo dei dati partizionati con l'accumulo di gradienti, impostate l'argomento `backward_passes_per_step` sul numero di fasi di accumulo mentre effettui il wrapping del modello con il modulo [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel). Ciò garantisce che l'operazione `AllReduce` del gradiente tra i gruppi di replica del modello (gruppi di partizionamento) avvenga al limite dell'accumulo del gradiente. + Puoi eseguire il checkpoint dei tuoi modelli addestrati con il parallelismo dei dati frammentati utilizzando il checkpointing della libreria e. APIs `smp.save_checkpoint` `smp.resume_from_checkpoint` Per ulteriori informazioni, consulta [Verifica di un PyTorch modello distribuito (per la libreria di parallelismo dei SageMaker modelli v1.10.0 e successive)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-checkpoint). + Il comportamento del parametro di configurazione [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) cambia in base al parallelismo dei dati partizionati. Quando queste due funzionalità sono attivate contemporaneamente, i parametri vengono inizializzati immediatamente dopo la creazione del modello in modo partizionato anziché ritardare l'inizializzazione dei parametri, in modo che ogni classificazione inizializzi e memorizzi la propria partizione di parametri. + Quando è attivato il parallelismo dei dati partizionati, la libreria esegue internamente il ritaglio del gradiente durante l'esecuzione della chiamata `optimizer.step()`. Non è necessario utilizzare l'utilità per il ritaglio del gradiente, ad APIs esempio. [https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html) Per regolare il valore di soglia per il ritaglio del gradiente, potete impostarlo tramite il `sdp_gradient_clipping` parametro per la configurazione dei parametri di distribuzione quando costruite lo stimatore, come mostrato nella sezione. SageMaker PyTorch [Come applicare il parallelismo dei dati partizionati al tuo processo di addestramento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use) # Pipeline di un modello Una delle caratteristiche principali della libreria di parallelismo dei modelli SageMaker è il parallelismo delle *pipeline, che determina l'ordine in cui vengono eseguiti* i calcoli e i dati vengono elaborati tra i dispositivi durante l'addestramento del modello. Il pipelining è una tecnica per ottenere una vera parallelizzazione nel parallelismo dei modelli, mediante l' GPUs elaborazione simultanea su diversi campioni di dati, e per superare la perdita di prestazioni dovuta al calcolo sequenziale. Quando si utilizza il parallelismo delle pipeline, il processo di addestramento viene eseguito in con pipeline su microbatch per massimizzare l'utilizzo della GPU. **Nota** Il parallelismo delle pipeline, chiamato anche partizionamento dei modelli, è disponibile per entrambi e. PyTorch TensorFlow Per le versioni supportate dei framework, consulta [Framework supportati e Regioni AWS](distributed-model-parallel-support.md). ## Pianificazione di esecuzione della pipeline Il pipelining si basa sulla suddivisione di un mini-batch in microbatch, che vengono inseriti nella pipeline one-by-one di formazione e seguono un programma di esecuzione definito dal runtime della libreria. Un *microbatch* è un sottoinsieme più piccolo di un determinato mini-batch di addestramento. La pianificazione della pipeline determina quale microbatch viene eseguito da quale dispositivo per ogni fascia oraria. Ad esempio, a seconda della pianificazione della pipeline e della partizione del modello, la GPU `i` potrebbe eseguire il calcolo (in avanti o all'indietro) sul microbatch mentre la GPU `i+1` esegue il calcolo sul microbatch, `b` mantenendo così entrambi attivi contemporaneamente. `b+1` GPUs Durante un singolo passaggio in avanti o indietro, il flusso di esecuzione di un singolo microbatch potrebbe visitare lo stesso dispositivo più volte, a seconda della decisione di partizionamento. Ad esempio, un'operazione che si trova all'inizio del modello potrebbe essere posizionata sullo stesso dispositivo come operazione alla fine del modello, mentre le operazioni intermedie avvengono su dispositivi diversi, il che significa che il dispositivo viene visitato due volte. La libreria offre due diverse pianificazioni di pipeline, *semplici* e *interlacciate*, che possono essere configurate utilizzando il `pipeline` parametro nell'SDK Python SageMaker . Nella maggior parte dei casi, una pipeline interlacciata può ottenere prestazioni migliori utilizzando la pipeline in modo più efficiente. GPUs ### Pipeline interlacciata In una pipeline interlacciata, quando possibile, viene data priorità all'esecuzione all'indietro dei microbatch. Ciò consente un rilascio più rapido della memoria utilizzata per le attivazioni, utilizzando la memoria in modo più efficiente. Consente inoltre di aumentare il numero di microbatch, riducendo il tempo di inattività di. GPUs Allo stato stazionario, ogni dispositivo alterna passaggi in avanti e indietro. Ciò significa che il passaggio all'indietro di un microbatch può essere eseguito prima del termine del passaggio in avanti di un altro microbatch. ![\[Esempio di pianificazione di esecuzione per la pipeline interlacciata su 2. GPUs\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-execution.png) La figura precedente illustra un esempio di programma di esecuzione per la pipeline interlacciata su 2. GPUs Nella figura, F0 rappresenta il passaggio in avanti del microbatch 0 e B1 rappresenta il passaggio all'indietro del microbatch 1. **Update rappresenta l'aggiornamento** dei parametri da parte dell'ottimizzatore. GPU0 dà sempre la priorità ai passaggi all'indietro quando possibile (ad esempio, esegue B0 prima di F2), il che consente di cancellare la memoria utilizzata per le attivazioni precedenti. ### Pipeline semplice Una pipeline semplice, al contrario, termina l'esecuzione del passaggio in avanti di ogni microbatch prima di iniziare il passaggio all'indietro. Ciò significa che convoglia solo le fasi di passaggio in avanti e indietro all'interno di se stesse. La figura seguente illustra un esempio di come funziona, più di 2. GPUs ![\[Esempio di pipeline che esegue il passaggio in avanti di ogni microbatch prima di iniziare il passaggio all’indietro.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/simple-pipeline-execution.png) ### Esecuzione della pipeline in framework specifici Utilizza le sezioni seguenti per conoscere la libreria di modelli di parallelismo creata dalla libreria di modelli di parallelismo delle decisioni di pianificazione della pipeline specifica SageMaker del framework per e. TensorFlow PyTorch #### Esecuzione della pipeline con TensorFlow L'immagine seguente è un esempio di un TensorFlow grafico partizionato dalla libreria di parallelismo del modello, utilizzando la suddivisione automatica del modello. Quando un grafico viene suddiviso, ogni sottografo risultante viene replicato B volte (ad eccezione delle variabili), dove B è il numero di microbatch. In questa figura, ogni grafico secondario viene replicato 2 volte (B=2). Un'operazione `SMPInput` viene inserita in ogni input di un grafico secondario e un'operazione `SMPOutput` viene inserita in ogni output. Queste operazioni comunicano con il back-end della libreria per trasferire i tensori da e verso gli altri. ![\[Esempio di TensorFlow grafico partizionato dalla libreria di parallelismo dei modelli, utilizzando la suddivisione automatica del modello.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.png) L'immagine seguente è un esempio di 2 grafici secondari suddivisi con B=2 con l'aggiunta di operazioni di gradiente. Il gradiente di un'operazione `SMPInput` è un'operazione `SMPOutput` e viceversa. Ciò consente ai gradienti di fluire all'indietro durante la retropropagazione. ![\[L’immagine seguente è un esempio di 2 sottografi suddivisi con B=2 con operazioni di gradiente aggiunte.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.gif) Questa GIF mostra un esempio di pianificazione di esecuzione di una pipeline interlacciata con microbatch B=2 e 2 grafici secondari. Ogni dispositivo esegue in sequenza una delle repliche dei grafici secondari per migliorare l'utilizzo della GPU. Man mano che B aumenta, la frazione degli intervalli di inattività scende a zero. Ogni volta che è il momento di eseguire calcoli (in avanti o indietro) su una specifica replica di grafico secondario, il livello della pipeline segnala alle corrispondenti operazioni blu di iniziare l'esecuzione `SMPInput`. Una volta calcolati i gradienti di tutti i microbatch di un singolo mini-batch, la libreria combina i gradienti tra i microbatch, che possono quindi essere applicati ai parametri. #### Esecuzione della pipeline con PyTorch Concettualmente, il pipelining segue un'idea simile in. PyTorch Tuttavia, poiché PyTorch non prevede grafici statici, la PyTorch funzionalità della libreria di parallelismo dei modelli utilizza un paradigma di pipelining più dinamico. Ad esempio TensorFlow, ogni batch è suddiviso in una serie di microbatch, che vengono eseguiti uno alla volta su ciascun dispositivo. Tuttavia, la pianificazione dell'esecuzione viene gestita tramite i server di esecuzione avviati su ciascun dispositivo. Ogni volta che l'output di un sottomodulo posizionato su un altro dispositivo è necessario sul dispositivo corrente, viene inviata una richiesta di esecuzione al server di esecuzione del dispositivo remoto insieme ai tensori di input al sottomodulo. Il server esegue quindi questo modulo con gli input forniti e restituisce la risposta al dispositivo corrente. Poiché il dispositivo corrente è inattivo durante l'esecuzione del sottomodulo remoto, l'esecuzione locale del microbatch corrente viene messa in pausa e il runtime della libreria commuta l'esecuzione su un altro microbatch su cui il dispositivo corrente può lavorare attivamente. La prioritizzazione dei microbatch è determinata dalla pianificazione della pipeline scelta. Per una pianificazione di pipeline interlacciata, ai microbatch che si trovano nella fase precedente del calcolo viene data priorità ogni volta che è possibile. # Parallelismo tensoriale Il *parallelismo tensoriale* è un tipo di parallelismo del modello in cui pesi, gradienti e stati dell'ottimizzatore specifici del modello vengono suddivisi tra i dispositivi. A differenza del parallelismo delle pipeline, che mantiene intatti i singoli pesi ma partiziona il *set* dei pesi, il parallelismo tensoriale suddivide i pesi individuali. Ciò comporta in genere il calcolo distribuito di operazioni, moduli o livelli specifici del modello. Il parallelismo tensoriale è necessario nei casi in cui un singolo parametro consuma la maggior parte della memoria della GPU (ad esempio tabelle di incorporamento di grandi dimensioni con un vocabolario di grandi dimensioni un livello softmax di grandi dimensioni con un numero elevato di classi). In questo caso, trattare questo tensore o operazione di grandi dimensioni come un'unità atomica è inefficiente e impedisce l'equilibrio del carico di memoria. Il parallelismo tensoriale è utile anche per modelli estremamente grandi in cui una pipeline pura semplicemente non è sufficiente. Ad esempio, con i modelli in scala GPT-3 che richiedono il partizionamento su decine di istanze, effettuare la pipeline in microbatch puro è inefficiente perché la profondità della pipeline diventa troppo elevata e il sovraccarico diventa proibitivo. **Nota** Il parallelismo tensoriale è disponibile PyTorch nella libreria di parallelismo dei SageMaker modelli v1.6.0 e successive. **Topics** + [Come funziona il Parallelismo tensoriale](model-parallel-extended-features-pytorch-tensor-parallelism-how-it-works.md) + [Esegui un processo di formazione parallela SageMaker su modelli distribuiti con Tensor Parallelism](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md) + [Supporto per i modelli Hugging Face Transformer](model-parallel-extended-features-pytorch-hugging-face.md) + [Meccanismo di classificazione quando si utilizza una combinazione di parallelismo di pipeline e parallelismo tensoriale](model-parallel-extended-features-pytorch-ranking-mechanism.md) # Come funziona il Parallelismo tensoriale Il parallelismo tensoriale avviene a livello di `nn.Modules`; partiziona moduli specifici nel modello tra classificazioni tensoriali parallele. Ciò si aggiunge alla partizione esistente del *set di moduli* utilizzati nel parallelismo delle pipeline. Quando un modulo viene partizionato tramite il parallelismo tensoriale, la sua propagazione in avanti e all'indietro viene distribuita. La libreria gestisce la comunicazione necessaria tra i dispositivi per implementare l'esecuzione distribuita di questi moduli. I moduli sono partizionati su più classificazioni di dati parallele. Contrariamente alla distribuzione tradizionale dei carichi di lavoro, ogni classificazione di parallelismo dei dati **non** ha la replica completa del modello quando viene utilizzato il parallelismo tensoriale della libreria. Invece, ogni classificazione di parallelismo dei dati può avere solo una partizione dei moduli distribuiti, oltre alla totalità dei moduli che non sono distribuiti. **Esempio:** considera il parallelismo tensoriale tra le classificazioni di dati parallele, dove il grado di parallelismo dei dati è 4 e il grado di parallelismo tensoriale è 2. Supponiamo di avere un gruppo parallelo di dati che contiene il seguente albero di moduli, dopo aver partizionato il set di moduli. ``` A ├── B | ├── E | ├── F ├── C └── D ├── G └── H ``` Supponiamo che il parallelismo tensoriale sia supportato per i moduli B, G e H. Un possibile risultato della partizione parallela tensoriale di questo modello potrebbe essere: ``` dp_rank 0 (tensor parallel rank 0): A, B:0, C, D, G:0, H dp_rank 1 (tensor parallel rank 1): A, B:1, C, D, G:1, H dp_rank 2 (tensor parallel rank 0): A, B:0, C, D, G:0, H dp_rank 3 (tensor parallel rank 1): A, B:1, C, D, G:1, H ``` Ogni riga rappresenta l'insieme di moduli memorizzati in `dp_rank`, e la notazione `X:y` rappresenta la frazione `y` del modulo `X`. Tenere presente quanto segue: 1. Il partizionamento avviene tra sottoinsiemi di classificazioni di dati paralleli, che chiamiamo `TP_GROUP`, non l'intero `DP_GROUP`, in modo che la partizione esatta del modello venga replicata su `dp_rank` 0 e `dp_rank` 2 e analogamente su `dp_rank` 1 e `dp_rank` 3. 1. I moduli `E` e `F` non fanno più parte del modello, poiché il loro modulo principale `B` è partizionato e qualsiasi esecuzione che normalmente fa parte di `E` e `F` avviene all'interno del modulo (partizionato) `B`. 1. Anche se `H` è supportato per il parallelismo tensoriale, in questo esempio non è partizionato, il che evidenzia che il partizionamento di un modulo dipende dall'input dell'utente. Il fatto che un modulo sia supportato per il parallelismo tensoriale non significa necessariamente che sia partizionato. ## Come la libreria adatta il PyTorch `nn.Linear` parallelismo tensoriale al modulo Quando il parallelismo tensoriale viene eseguito su classificazioni di dati parallele, un sottoinsieme dei parametri, dei gradienti e degli stati dell'ottimizzatore viene partizionato tra i dispositivi paralleli tensoriali *per i moduli partizionati*. Per il resto dei moduli, i dispositivi paralleli tensoriali funzionano in modo normale in parallelo ai dati. Per eseguire il modulo partizionato, un dispositivo raccoglie innanzitutto le parti necessarie di *tutti i campioni di dati* su dispositivi peer nello stesso gruppo di parallelismo tensoriale. Il dispositivo esegue quindi la frazione locale del modulo su tutti questi campioni di dati, seguita da un altro ciclo di sincronizzazione che combina le parti dell'output per ciascun campione di dati e restituisce i campioni di dati combinati al punto GPUs da cui ha avuto origine il campione di dati. La figura seguente mostra un esempio di questo processo su un modulo partizionato `nn.Linear`. ![\[Due figure che mostrano due concetti di parallelizzazione dei tensori.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-concept.png) La prima figura mostra un modello piccolo con un modulo `nn.Linear` grande con parallelismo dei dati sulle due classificazioni di parallelismo tensoriale. Il modulo `nn.Linear` viene replicato nelle due classificazioni parallele. La seconda figura mostra il parallelismo tensoriale applicato su un modello più grande durante la suddivisione del modulo `nn.Linear`. Ciascun `tp_rank` contiene metà del modulo lineare e la totalità del resto delle operazioni. Durante il funzionamento del modulo lineare, ogni `tp_rank` raccoglie la metà pertinente di tutti i campioni di dati e la trasmette attraverso la propria metà del modulo `nn.Linear`. Il risultato deve essere ridotto (con la somma come operazione di riduzione) in modo che ogni classificazione abbia l'output lineare finale dei propri campioni di dati. Il resto del modello viene eseguito nel tipico modo parallelo dei dati. # Esegui un processo di formazione parallela SageMaker su modelli distribuiti con Tensor Parallelism In questa sezione, imparerai: + Come configurare uno SageMaker PyTorch stimatore e l'opzione di parallelismo del SageMaker modello per utilizzare il parallelismo tensoriale. + Come adattare lo script di addestramento utilizzando i moduli `smdistributed.modelparallel` estesi per il parallelismo tensoriale. Per saperne di più sui `smdistributed.modelparallel` moduli, consulta il [SageMaker modello parallel APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) nella documentazione di *SageMaker Python SDK*. **Topics** + [Solo parallelismo tensoriale](#model-parallel-extended-features-pytorch-tensor-parallelism-alone) + [Parallelismo tensoriale combinato con parallelismo di pipeline](#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism) ## Solo parallelismo tensoriale Quello che segue è un esempio di un opzione di addestramento distribuito per attivare il solo parallelismo tensoriale, senza il parallelismo della pipeline. Configura i `smp_options` dizionari `mpi_options` and per specificare le opzioni di formazione distribuite allo estimatore. SageMaker `PyTorch` **Nota** Le funzionalità estese di risparmio della memoria sono disponibili tramite Deep Learning Containers for PyTorch, che implementa la libreria di parallelismo dei SageMaker modelli v1.6.0 o successiva. **Configura uno stimatore SageMaker PyTorch ** ``` mpi_options = { "enabled" : True, "processes_per_host" : 8,               # 8 processes "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none " }                 smp_options = { "enabled":True, "parameters": { "pipeline_parallel_degree": 1,    # alias for "partitions" "placement_strategy": "cluster", "tensor_parallel_degree": 4,      # tp over 4 devices "ddp": True } }                smp_estimator = PyTorch(    entry_point='your_training_script.py', # Specify    role=role,    instance_type='ml.p3.16xlarge',    sagemaker_session=sagemaker_session,    framework_version='1.13.1', py_version='py36',    instance_count=1,    distribution={        "smdistributed": {"modelparallel": smp_options},        "mpi": mpi_options    },    base_job_name="SMD-MP-demo", ) smp_estimator.fit('s3://my_bucket/my_training_data/') ``` **Suggerimento** Per trovare un elenco completo dei parametri per`distribution`, consulta Parametri di [configurazione per il parallelismo dei modelli nella documentazione](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html) di SageMaker Python SDK. **Adatta il tuo script di allenamento PyTorch ** Lo script di addestramento di esempio seguente mostra come adattare la libreria di parallelismo dei SageMaker modelli a uno script di addestramento. In questo esempio, si presume che lo script abbia il nome `your_training_script.py`. ``` import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchnet.dataset import SplitDataset from torchvision import datasets import smdistributed.modelparallel.torch as smp class Net(nn.Module):     def __init__(self):         super(Net, self).__init__()         self.conv1 = nn.Conv2d(1, 32, 3, 1)         self.conv2 = nn.Conv2d(32, 64, 3, 1)         self.fc1 = nn.Linear(9216, 128)         self.fc2 = nn.Linear(128, 10)     def forward(self, x):         x = self.conv1(x)         x = F.relu(x)         x = self.conv2(x)         x = F.relu(x)         x = F.max_pool2d(x, 2)         x = torch.flatten(x, 1)         x = self.fc1(x)         x = F.relu(x)         x = self.fc2(x)         return F.log_softmax(x, 1) def train(model, device, train_loader, optimizer):     model.train()     for batch_idx, (data, target) in enumerate(train_loader):         # smdistributed: Move input tensors to the GPU ID used by         # the current process, based on the set_device call.         data, target = data.to(device), target.to(device)         optimizer.zero_grad()         output = model(data)         loss = F.nll_loss(output, target, reduction="mean")         loss.backward()         optimizer.step() # smdistributed: Initialize the backend smp.init() # smdistributed: Set the device to the GPU ID used by the current process. # Input tensors should be transferred to this device. torch.cuda.set_device(smp.local_rank()) device = torch.device("cuda") # smdistributed: Download only on a single process per instance. # When this is not present, the file is corrupted by multiple processes trying # to download and extract at the same time if smp.local_rank() == 0:     dataset = datasets.MNIST("../data", train=True, download=False) smp.barrier() # smdistributed: Shard the dataset based on data parallel ranks if smp.dp_size() > 1:     partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}     dataset = SplitDataset(dataset, partitions=partitions_dict)     dataset.select(f"{smp.dp_rank()}") train_loader = torch.utils.data.DataLoader(dataset, batch_size=64) # smdistributed: Enable tensor parallelism for all supported modules in the model # i.e., nn.Linear in this case. Alternatively, we can use # smp.set_tensor_parallelism(model.fc1, True) # to enable it only for model.fc1 with smp.tensor_parallelism():     model = Net() # smdistributed: Use the DistributedModel wrapper to distribute the # modules for which tensor parallelism is enabled model = smp.DistributedModel(model) optimizer = optim.AdaDelta(model.parameters(), lr=4.0) optimizer = smp.DistributedOptimizer(optimizer) train(model, device, train_loader, optimizer) ``` ## Parallelismo tensoriale combinato con parallelismo di pipeline Di seguito è riportato un esempio di opzione di addestramento distribuita che abilita il parallelismo tensoriale combinato con il parallelismo della pipeline. Imposta i `smp_options` parametri `mpi_options` and per specificare le opzioni parallele del modello con parallelismo tensoriale quando configuri uno stimatore. SageMaker `PyTorch` **Nota** Le funzionalità estese di risparmio della memoria sono disponibili tramite Deep Learning Containers for PyTorch, che implementa la libreria di parallelismo dei SageMaker modelli v1.6.0 o successiva. **Configura uno stimatore SageMaker PyTorch ** ``` mpi_options = { "enabled" : True, "processes_per_host" : 8,               # 8 processes "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none " }                 smp_options = { "enabled":True, "parameters": { "microbatches": 4, "pipeline_parallel_degree": 2,    # alias for "partitions" "placement_strategy": "cluster", "tensor_parallel_degree": 2,      # tp over 2 devices "ddp": True } }                smp_estimator = PyTorch(    entry_point='your_training_script.py', # Specify    role=role,    instance_type='ml.p3.16xlarge',    sagemaker_session=sagemaker_session,    framework_version='1.13.1', py_version='py36',    instance_count=1,    distribution={        "smdistributed": {"modelparallel": smp_options},        "mpi": mpi_options    },    base_job_name="SMD-MP-demo", ) smp_estimator.fit('s3://my_bucket/my_training_data/')   ``` **Adatta il tuo script PyTorch di allenamento** Lo script di addestramento di esempio seguente mostra come adattare la libreria di parallelismo dei SageMaker modelli a uno script di addestramento. Nota che lo script di addestramento ora include il decoratore `smp.step`: ``` import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchnet.dataset import SplitDataset from torchvision import datasets import smdistributed.modelparallel.torch as smp class Net(nn.Module):     def __init__(self):         super(Net, self).__init__()         self.conv1 = nn.Conv2d(1, 32, 3, 1)         self.conv2 = nn.Conv2d(32, 64, 3, 1)         self.fc1 = nn.Linear(9216, 128)         self.fc2 = nn.Linear(128, 10)     def forward(self, x):         x = self.conv1(x)         x = F.relu(x)         x = self.conv2(x)         x = F.relu(x)         x = F.max_pool2d(x, 2)         x = torch.flatten(x, 1)         x = self.fc1(x)         x = F.relu(x)         x = self.fc2(x)         return F.log_softmax(x, 1) # smdistributed: Define smp.step. Return any tensors needed outside. @smp.step def train_step(model, data, target):     output = model(data)     loss = F.nll_loss(output, target, reduction="mean")     model.backward(loss)     return output, loss def train(model, device, train_loader, optimizer):     model.train()     for batch_idx, (data, target) in enumerate(train_loader):         # smdistributed: Move input tensors to the GPU ID used by         # the current process, based on the set_device call.         data, target = data.to(device), target.to(device)         optimizer.zero_grad()         # Return value, loss_mb is a StepOutput object         _, loss_mb = train_step(model, data, target)         # smdistributed: Average the loss across microbatches.         loss = loss_mb.reduce_mean()         optimizer.step() # smdistributed: Initialize the backend smp.init() # smdistributed: Set the device to the GPU ID used by the current process. # Input tensors should be transferred to this device. torch.cuda.set_device(smp.local_rank()) device = torch.device("cuda") # smdistributed: Download only on a single process per instance. # When this is not present, the file is corrupted by multiple processes trying # to download and extract at the same time if smp.local_rank() == 0:     dataset = datasets.MNIST("../data", train=True, download=False) smp.barrier() # smdistributed: Shard the dataset based on data parallel ranks if smp.dp_size() > 1:     partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}     dataset = SplitDataset(dataset, partitions=partitions_dict)     dataset.select(f"{smp.dp_rank()}") # smdistributed: Set drop_last=True to ensure that batch size is always divisible # by the number of microbatches train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True) model = Net() # smdistributed: enable tensor parallelism only for model.fc1 smp.set_tensor_parallelism(model.fc1, True) # smdistributed: Use the DistributedModel container to provide the model # to be partitioned across different ranks. For the rest of the script, # the returned DistributedModel object should be used in place of # the model provided for DistributedModel class instantiation. model = smp.DistributedModel(model) optimizer = optim.AdaDelta(model.parameters(), lr=4.0) optimizer = smp.DistributedOptimizer(optimizer) train(model, device, train_loader, optimizer) ``` # Supporto per i modelli Hugging Face Transformer Il parallelismo tensoriale della libreria di parallelismo dei SageMaker modelli offre supporto per i seguenti modelli Hugging out-of-the-box Face Transformer: + GPT-2, BERT e Ro (disponibili nella libreria di parallelismo dei modelli v1.7.0 e successiveBERTa ) SageMaker + GPT-J (disponibile nella libreria di parallelismo dei modelli v1.8.0 e successive) SageMaker + GPT-Neo (disponibile nella libreria di parallelismo dei modelli v1.10.0 e successive) SageMaker **Nota** [Per qualsiasi altro modello Transformers, è necessario utilizzare l'API smdistributed.modelparallel.torch.tp\$1register\$1with\$1module()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tp_register_with_module) per applicare il parallelismo tensoriale. **Nota** Per utilizzare il parallelismo tensoriale per addestrare i modelli Hugging Face Transformer, assicurati di utilizzare Hugging Face Deep Learning Containers perché ha la libreria di parallelismo dei modelli v1.7.0 e successive. PyTorch SageMaker Per ulteriori informazioni[, SageMaker consulta le](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) note di rilascio della libreria Model Parallelism. ## Modelli supportati pronti all'uso Per i modelli di trasformatori Hugging Face supportati dalla libreria pronti all'uso, non è necessario implementare manualmente gli hook per tradurre Transformer in livelli di trasformatore. APIs `smdistributed` [È possibile attivare il parallelismo tensoriale utilizzando il gestore di contesto smdistributed.modelparallel.torch.tensor\$1parallelism () e avvolgendo il modello con smdistributed.modelparallel.torch.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tensor_parallelism) [ DistributedModel().](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel) Non è necessario registrare manualmente gli hook per il parallelismo tensoriale utilizzando l'API `smp.tp_register`. È possibile accedere alle funzioni di traduzione `state_dict` tra Hugging Face Transformers e `smdistributed.modelparallel` come segue. + `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_state_dict_to_hf_gpt2(state_dict, max_seq_len=None)` + `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_hf_state_dict_to_smdistributed_gpt2(state_dict)` + `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_state_dict_to_hf_bert(state_dict, max_seq_len=None)` + `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_hf_state_dict_to_smdistributed_bert(state_dict)` + `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_state_dict_to_hf_roberta(state_dict, max_seq_len=None)` + `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_hf_state_dict_to_smdistributed_roberta(state_dict)` + `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_state_dict_to_hf_gptj(state_dict, max_seq_len=None)`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.8.0 e successive) + `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.8.0 e successive) + `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.10.0 e successive) + `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.10.0 e successive) **Esempio di utilizzo della funzione di traduzione GPT-2** Inizia effettuando il wrapping del modello come mostrato nel codice seguente. ``` from transformers import AutoModelForCausalLM with smp.tensor_parallelism(): model = AutoModelForCausalLM.from_config(hf_gpt2_config) model = smp.DistributedModel(model) ``` Dato un `state_dict` dall'oggetto `DistributedModel`, puoi caricare i pesi nel modello Hugging Face GPT-2 originale usando la funzione `translate_state_dict_to_hf_gpt2` mostrata nel codice seguente. ``` from smdistributed.modelparallel.torch.nn.huggingface.gpt2 \ import translate_state_dict_to_hf_gpt2 max_seq_len = 1024 # [... code block for training ...] if smp.rdp_rank() == 0: state_dict = dist_model.state_dict() hf_state_dict = translate_state_dict_to_hf_gpt2(state_dict, max_seq_len) # can now call model.load_state_dict(hf_state_dict) to the original HF model ``` **Esempio di utilizzo della funzione di traduzione Ro BERTa ** Allo stesso modo, dato un HuggingFace modello supportato`state_dict`, è possibile utilizzare la `translate_hf_state_dict_to_smdistributed` funzione per convertirlo in un formato leggibile da`smp.DistributedModel`. Questo può essere utile nei casi d'uso di apprendimento del trasferimento, in cui un modello pre-addestrato viene caricato in un `smp.DistributedModel` per l'ottimizzazione in parallelo del modello: ``` from smdistributed.modelparallel.torch.nn.huggingface.roberta \ import translate_state_dict_to_smdistributed model = AutoModelForMaskedLM.from_config(roberta_config) model = smp.DistributedModel(model) pretrained_model = AutoModelForMaskedLM.from_pretrained("roberta-large") translated_state_dict = translate_state_dict_to_smdistributed(pretrained_model.state_dict()) # load the translated pretrained weights into the smp.DistributedModel model.load_state_dict(translated_state_dict) # start fine-tuning... ``` # Meccanismo di classificazione quando si utilizza una combinazione di parallelismo di pipeline e parallelismo tensoriale Questa sezione spiega come funziona il meccanismo di classificazione del parallelismo dei modelli con il parallelismo tensoriale. Si tratta di un'estensione di [Ranking Basics](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#ranking-basics) per [Caratteristiche principali della SageMaker Model Parallelism Library](model-parallel-core-features.md). Con il parallelismo tensoriale, la libreria introduce tre tipi di classificazione e gruppo di processi: APIs per `smp.tp_rank()` tensor parallel rank, per `smp.pp_rank()` pipeline parallel rank e per reduced-data parallel rank. `smp.rdp_rank()` I gruppi di processi di comunicazione corrispondenti sono gruppo parallelo dei tensori (`TP_GROUP`), gruppo parallelo di pipeline (`PP_GROUP`) e gruppo parallelo dei dati ridotti (`RDP_GROUP`). I gruppi sono definiti come segue: + Un *gruppo parallelo dei tensori* (`TP_GROUP`) è un sottoinsieme divisibile in modo uniforme del gruppo parallelo dei dati, sul quale avviene la distribuzione parallela tensoriale dei moduli. Quando il grado di parallelismo della pipeline è 1, `TP_GROUP` è uguale al *gruppo parallelo del modello* (`MP_GROUP`). + Un *gruppo parallelo di pipeline* (`PP_GROUP`) è il gruppo di processi su cui avviene il parallelismo della pipeline. Quando il grado di parallelismo tensoriale è 1, `PP_GROUP` è uguale a `MP_GROUP`. + Un gruppo *parallelo dei dati ridotti* (`RDP_GROUP`) è un insieme di processi che contengono sia le stesse partizioni di parallelismo della pipeline che le stesse partizioni parallele tensoriali ed eseguono il parallelismo dei dati tra di loro. Questo è chiamato gruppo parallelo dei dati ridotti perché è un sottoinsieme dell'intero gruppo di parallelismo dei dati `DP_GROUP`. Per i parametri del modello distribuito all'interno di `TP_GROUP`, l'operazione `allreduce` di gradiente viene eseguita solo per il gruppo parallelo dei dati ridotti, mentre per i parametri che non sono distribuiti, il gradiente `allreduce` avviene sull'intero `DP_GROUP`. + Un gruppo parallelo del modello (`MP_GROUP`) si riferisce a un gruppo di processi che memorizzano collettivamente l'intero modello. Consiste nell'unione degli `PP_GROUP` di tutte le classificazioni che fanno parte del processo corrente `TP_GROUP`. Quando il grado di parallelismo tensoriale è 1, `MP_GROUP` è equivalente a `PP_GROUP` È inoltre coerente con la definizione esistente di `MP_GROUP` delle versioni precedenti `smdistributed`. Nota che il `TP_GROUP` corrente è un sottoinsieme sia della `DP_GROUP` corrente che del `MP_GROUP` corrente. *Per saperne di più sul processo di comunicazione APIs nella libreria di parallelismo dei SageMaker modelli, consulta l'[API Common](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html#) e [PyTorch-specific](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) nella documentazione di Python APIs SageMaker SDK.* ![\[Meccanismo di classificazione, distribuzione dei parametri e operazioni associate AllReduce del parallelismo tensoriale.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-ranking-mechanism.png) Ad esempio, considerate i gruppi di processi per un singolo nodo con 8 GPUs, dove il grado di parallelismo tensoriale è 2, il grado di parallelismo della pipeline è 2 e il grado di parallelismo dei dati è 4. La parte centrale superiore della figura precedente mostra un esempio di modello con 4 livelli. Le parti in basso a sinistra e in basso a destra della figura illustrano il modello a 4 strati distribuito su 4 GPUs utilizzando sia il parallelismo della pipeline che il parallelismo tensoriale, dove il parallelismo tensoriale viene utilizzato per i due strati intermedi. Queste due figure inferiori sono semplici copie che illustrano le diverse linee di confine dei gruppi. Il modello partizionato viene replicato per il parallelismo dei dati su 0-3 e 4-7. GPUs La figura in basso a sinistra mostra le definizioni di `MP_GROUP`, `PP_GROUP`, e `TP_GROUP`. La figura in basso a destra mostra`RDP_GROUP`, `DP_GROUP` e sullo stesso set di. `WORLD` GPUs I gradienti per i livelli e le porzioni di livello che hanno lo stesso colore vengono `allreduce` assieme per il parallelismo dei dati. Ad esempio, il primo livello (blu chiaro) riceve le operazioni `allreduce` attraverso `DP_GROUP`, mentre la sezione arancione scuro del secondo livello trasmette solo le operazioni `allreduce` all'interno del relativo processo `RDP_GROUP`. Le frecce in grassetto rosso scuro rappresentano i tensori con il batch del loro insieme `TP_GROUP`. ``` GPU0: pp_rank 0, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 0 GPU1: pp_rank 1, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 1 GPU2: pp_rank 0, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 2 GPU3: pp_rank 1, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 3 GPU4: pp_rank 0, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 0 GPU5: pp_rank 1, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 1 GPU6: pp_rank 0, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 2 GPU7: pp_rank 1, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 3 ``` In questo esempio, il parallelismo di pipeline si verifica tra le coppie di GPU (0,1); (2,3); (4,5) e (6,7). Inoltre, il parallelismo dei dati (`allreduce`) avviene su GPUs 0, 2, 4, 6 e indipendentemente su GPUs 1, 3, 5, 7. Il parallelismo tensoriale avviene su sottoinsiemi di `DP_GROUP`, tra le coppie di GPU (0,2); (1,3); (4,6) e (5,7). Per questo tipo di parallelismo ibrido tra pipeline e tensori, la matematica per `data_parallel_degree` rimane la stessa di `data_parallel_degree = number_of_GPUs / pipeline_parallel_degree`. La libreria calcola ulteriormente il grado di parallelismo dei dati ridotti dalla seguente relazione `reduced_data_parallel_degree * tensor_parallel_degree = data_parallel_degree`. # Partizione dello stato dell'ottimizzatore La *partizione dello stato dell'ottimizzatore* è un'utile tecnica di risparmio di memoria che partiziona lo stato dell'ottimizzatore (l'insieme di pesi che descrive lo stato dell'ottimizzatore) tra gruppi di dispositivi paralleli di dati. È possibile utilizzare la suddivisione dello stato dell'ottimizzatore ogni volta che si utilizza un ottimizzatore con stato (come Adam) o un FP16 ottimizzatore (che memorizza entrambi i parametri e le copie dei parametri). FP16 FP32 **Nota** Lo sharding dello stato dell'ottimizzatore è disponibile PyTorch nella libreria di parallelismo dei modelli v1.6.0 e versioni successive. SageMaker ## Come usare la partizione dello stato dell'ottimizzatore È possibile attivare la *partizione dello stato dell'ottimizzatore* impostando `"shard_optimizer_state": True` nella configurazione `modelparallel`. Quando questa funzione è attivata, la libreria partiziona il set di parametri del modello in base al grado di parallelismo dei dati. I gradienti corrispondenti alla partizione `i` vengono ridotti solo alla classificazione parallela dei dati `i`. Alla fine della prima chiamata a una funzione decoratrice `smp.step`, l'ottimizzatore racchiuso da `smp.DistributedOptimizer` ridefinisce i suoi parametri in modo che siano limitati solo a quelli corrispondenti alla partizione dell'attuale classificazione dei dati parallela. I parametri ridefiniti sono chiamati *parametri virtuali* e condividono lo spazio di archiviazione sottostante con i parametri originali. Durante la prima chiamata a `optimizer.step`, gli stati dell'ottimizzatore vengono creati in base a questi parametri ridefiniti, che vengono partizionati a causa della partizione originale. Dopo l'aggiornamento dell'ottimizzatore, l' AllGatheroperazione (come parte della `optimizer.step` chiamata) viene eseguita su tutti i ranghi paralleli dei dati per ottenere stati dei parametri coerenti. **Suggerimento** La partizione dello stato dell'ottimizzatore può essere utile quando il grado di parallelismo dei dati è maggiore di 1 e il modello ha più di un miliardo di parametri. Il grado di parallelismo dei dati viene calcolato da `(processes_per_host * instance_count / pipeline_parallel_degree)` e la funzione `smp.dp_size()` gestisce il dimensionamento in background. **Configura uno stimatore SageMaker PyTorch ** ``` mpi_options = { "enabled" : True, "processes_per_host" : 8, # 8 processes "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none " } smp_options = { "enabled":True, "parameters": { "microbatches": 4, "pipeline_parallel_degree": 2, # alias for "partitions" "placement_strategy": "cluster", "tensor_parallel_degree": 2, # tp over 2 devices "ddp": True, "shard_optimizer_state": True } } ``` **Adatta il tuo script PyTorch di allenamento** Vedi [Adatta il tuo script di PyTorch formazione](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism-script) nella sezione Parallelismo di *Tensor combinato con parallelismo* della pipeline. Non è richiesta alcuna modifica aggiuntiva per lo script. # Checkpoint di attivazione Il *checkpoint di attivazione* (o *checkpoint gradiente*) è una tecnica per ridurre l'utilizzo della memoria cancellando le attivazioni di determinati livelli e ricalcolandole durante un passaggio all'indietro. In effetti, ciò consente di rinunciare a tempi di calcolo aggiuntivi per ridurre l'utilizzo della memoria. Se un modulo è sottoposto a checkpoint, alla fine di un passaggio in avanti, gli input e gli output dal modulo rimangono in memoria. Tutti i tensori intermedi che avrebbero fatto parte del calcolo all'interno di quel modulo vengono liberati durante il passaggio in avanti. Durante il passaggio all'indietro dei moduli di checkpoint, questi tensori vengono ricalcolati. A questo punto, i livelli oltre questo modulo di checkpoint hanno terminato il passaggio all'indietro, quindi il picco di utilizzo della memoria con il checkpoint può essere inferiore. **Nota** Questa funzionalità è disponibile PyTorch nella libreria di parallelismo dei modelli v1.6.0 e successive SageMaker . ## Come usare il checkpoint di attivazione Con `smdistributed.modelparallel`, è possibile utilizzare il checkpoint di attivazione con la granularità di un modulo. Per tutti i moduli `torch.nn` tranne `torch.nn.Sequential`, è possibile effettuare il checkpoint di un albero di moduli solo se si trova all'interno di una partizione dal punto di vista del parallelismo di pipeline. Nel caso del modulo `torch.nn.Sequential`, ogni albero dei moduli all'interno del modulo sequenziale deve trovarsi completamente all'interno di una partizione affinché il checkpoint di attivazione funzioni. Quando utilizzi il partizionamento manuale, tieni presente queste restrizioni. Quando si utilizza il [partizionamento automatico dei modelli](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-automated-model-splitting), è possibile trovare i registri delle assegnazioni di partizionamento a partire da `Partition assignments:` nei registri dei processi di addestramento. Se un modulo è partizionato su più livelli (ad esempio, con uno discendente su una classificazione e un altro discendente su una classificazione diversa), la libreria ignora il tentativo di checkpoint del modulo e genera un messaggio di avviso che indica che il modulo non verrà sottoposto a checkpoint. **Nota** La libreria di parallelismo dei SageMaker modelli supporta operazioni di sovrapposizione e non sovrapposizione in combinazione con il checkpoint. `allreduce` **Nota** PyTorchl'API di checkpointing nativa non è compatibile con. `smdistributed.modelparallel` **Esempio 1:** il seguente codice di esempio mostra come utilizzare il checkpoint di attivazione quando nello script è presente una definizione del modello. ``` import torch.nn as nn import torch.nn.functional as F from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 32, 3, 1) self.conv2 = nn.Conv2d(32, 64, 3, 1) self.fc1 = nn.Linear(9216, 128) self.fc2 = nn.Linear(128, 10) def forward(self, x): x = self.conv1(x) x = self.conv2(x) x = F.max_pool2d(x, 2) x = torch.flatten(x, 1) # This call of fc1 will be checkpointed x = checkpoint(self.fc1, x) x = self.fc2(x) return F.log_softmax(x, 1) ``` **Esempio 2:** il seguente codice di esempio mostra come utilizzare il checkpoint di attivazione quando nello script è presente un modello sequenziale. ``` import torch.nn as nn from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint_sequential class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.seq = nn.Sequential( nn.Conv2d(1,20,5), nn.ReLU(), nn.Conv2d(20,64,5), nn.ReLU() ) def forward(self, x): # This call of self.seq will be checkpointed x = checkpoint_sequential(self.seq, x) return F.log_softmax(x, 1) ``` **Esempio 3:** Il codice di esempio seguente mostra come utilizzare il checkpoint di attivazione quando si importa un modello predefinito da una libreria, ad esempio PyTorch Hugging Face Transformers. Indipendentemente dal fatto che tu faccia o meno il checkpoint dei i moduli sequenziali, procedi come segue: 1. Effettua il wrapping del modello per `smp.DistributedModel()`. 1. Definisci un oggetto per i livelli sequenziali. 1. Effettua il wrapping dell'oggetto del livello sequenziale con `smp.set_activation_checkpointig()`. ``` import smdistributed.modelparallel.torch as smp from transformers import AutoModelForCausalLM smp.init() model = AutoModelForCausalLM(*args, **kwargs) model = smp.DistributedModel(model) # Call set_activation_checkpointing API transformer_layers = model.module.module.module.transformer.seq_layers smp.set_activation_checkpointing( transformer_layers, pack_args_as_tuple=True, strategy='each') ``` # Offload di attivazione Quando il checkpoint di attivazione e il parallelismo di pipeline sono attivati e il numero di microbatch è maggiore di uno, l'*offload di attivazione* è una funzionalità aggiuntiva che può ridurre ulteriormente l'utilizzo della memoria. L'offload di attivazione sposta in modo asincrono le attivazioni dei checkpoint corrispondenti ai relativi microbatch che non sono attualmente in esecuzione nella CPU. Appena prima che la GPU richieda le attivazioni per il passaggio all'indietro del microbatch, questa funzionalità recupera automaticamente le offload di attivazione scaricate dalla CPU. **Nota** Questa funzionalità è disponibile PyTorch nella libreria di parallelismo dei modelli v1.6.0 e versioni successive SageMaker . ## Come usare l'offload di attivazione Utilizza l'offload di attivazione per ridurre l'utilizzo della memoria quando **il numero di microbatch è maggiore di 1 e il checkpoint di attivazione è attivato** (vedi[Checkpoint di attivazione](model-parallel-extended-features-pytorch-activation-checkpointing.md)). Quando il checkpoint di attivazione non viene utilizzato, l'offload di attivazione non ha alcun effetto. Quando viene utilizzato con un solo microbatch, non consente di risparmiare memoria. Per utilizzare l'offload di attivazione, impostalo `"offload_activations": True` nella configurazione `modelparallel`. L'offload di attivazione sposta le attivazioni dei checkpoint nei moduli `nn.Sequential` sulla CPU in modo asincrono. Il trasferimento dei dati tramite il PCIe collegamento si sovrappone al calcolo della GPU. L'offload avviene immediatamente, non appena viene calcolato il passaggio in avanti per un particolare livello sottoposto a checkpoint. Le attivazioni vengono caricate nuovamente sulla GPU poco prima di essere necessarie per il passaggio all'indietro di un particolare microbatch. Il trasferimento CPU-GPU si sovrappone in modo analogo al calcolo. Per regolare la data di caricamento anticipata delle attivazioni nella GPU, puoi utilizzare il parametro di configurazione `"activation_loading_horizon"` (il valore predefinito è impostato su 4, deve essere `int` maggiore di 0). Un orizzonte di caricamento delle attivazioni più ampio comporterebbe il caricamento anticipato delle attivazioni sulla GPU. Se l'orizzonte è troppo ampio, l'impatto dell'offload di attivazione in termini di risparmio di memoria potrebbe essere ridotto. Se l'orizzonte è troppo piccolo, le attivazioni potrebbero non essere caricate indietro nel tempo, riducendo la sovrapposizione e peggiorando le prestazioni. **Suggerimento** L'offload di attivazione può essere utile per modelli di grandi dimensioni con oltre cento miliardi di parametri. ** SageMaker PyTorch Configura uno stimatore** ``` mpi_options = { "enabled" : True, "processes_per_host" : 8, # 8 processes "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none " } smp_options = { "enabled":True, "parameters": { "microbatches": 4, "pipeline_parallel_degree": 2, # alias for "partitions" "placement_strategy": "cluster", "tensor_parallel_degree": 2, # tp over 2 devices "ddp": True, "offload_activations": True, "activation_loading_horizon": 4 # optional. default is 4. } } ``` # FP16 Formazione con Model Parallelism Per la FP16 formazione, applica le seguenti modifiche allo script di addestramento e allo stimatore. **Nota** Questa funzionalità è disponibile PyTorch nella libreria di parallelismo dei SageMaker modelli v1.10.0 e versioni successive. ** PyTorch Adatta il tuo script di allenamento** 1. Effettua il wrapping del modello usando il gestore di contesto [smdistributed.modelparallel.torch.model\$1creation](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.model_creation) (). ``` # fp16_training_script.py import torch import smdistributed.modelparallel.torch as smp with smp.model_creation( dtype=torch.float16 if args.fp16 else torch.get_default_dtype() ): model = ... ``` **Suggerimento** Se stai usando il parallelismo tensoriale, aggiungi `tensor_parallelism=smp.tp_size() > 1` al gestore di contesto `smp.model_creation`. L'aggiunta di questa linea aiuta anche a rilevare automaticamente se il parallelismo tensoriale è attivato o meno. ``` with smp.model_creation( ... , tensor_parallelism=smp.tp_size() > 1 ): model = ... ``` 1. Quando racchiudi l'ottimizzatore con `smdistributed.modelparallel.torch.DistributedOptimizer`, imposta l'argomento `static_loss_scaling` o `dynamic_loss_scaling`. Per impostazione predefinita, `static_loss_scaling` è impostato su `1.0` e `dynamic_loss_scaling` è impostato su `False`. Se imposti `dynamic_loss_scale=True`, puoi inserire le opzioni di dimensionamento dinamico delle perdite come dizionario tramite l'argomento `dynamic_loss_args`. Nella maggior parte dei casi, si consiglia di utilizzare la scala dinamica delle perdite con le opzioni predefinite. [Per ulteriori informazioni, opzioni ed esempi della funzione wrapper dell'ottimizzatore, consultate smdistributed.modelparallel.torch. DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedoptimizer) API. Il codice seguente è un esempio di avvolgimento di un oggetto `Adadelta` ottimizzatore con una scalatura dinamica delle perdite per l'addestramento. FP16 ``` optimizer = torch.optim.Adadelta(...) optimizer = smp.DistributedOptimizer( optimizer, static_loss_scale=None, dynamic_loss_scale=True, dynamic_loss_args={ "scale_window": 1000, "min_scale": 1, "delayed_shift": 2 } ) ``` **Configura uno stimatore SageMaker PyTorch ** Aggiungi il FP16 parametro (`"fp16"`) alla configurazione di distribuzione per il parallelismo del modello durante la creazione di un SageMaker PyTorch oggetto estimatore. Per un elenco completo dei parametri di configurazione per il parallelismo dei modelli, vedere [Parametri per `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed). ``` from sagemaker.pytorch import PyTorch smp_options = { "enabled": True, "parameters": { "microbatches": 4, "pipeline_parallel_degree": 2, "tensor_parallel_degree": 2, ..., "fp16": True } } fp16_estimator = PyTorch( entry_point="fp16_training_script.py", # Specify your train script ..., distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": {...} } ) fp16_estimator.fit(...) ``` [All'inizio dell' FP16 addestramento, il modello e l'ottimizzatore vengono integrati rispettivamente da `FP16_Module` e, `FP16_Optimizer` rispettivamente, `smdistributed` versioni modificate delle utilità Apex.](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils) `FP16_Module`converte il modello in FP16 dtype e si occupa del forward pass in. FP16 **Suggerimento** È possibile applicare il ritaglio del gradiente chiamando `clip_master_grads` prima di `optimizer.step`. ``` optimizer.clip_master_grads(max_norm) # max_norm(float or int): max norm of the gradients ``` **Suggerimento** Durante l'utilizzo `torch.optim.lr_scheduler` e l' FP16 addestramento, è necessario passare `optimizer.optimizer` allo scheduler LR anziché all'ottimizzatore. Guarda il codice di esempio seguente. ``` from torch.optim.lr_scheduler import StepLR scheduler = StepLR( optimizer.optimizer if smp.state.cfg.fp16 else optimizer, step_size=1, gamma=args.gamma ) ``` # Support per FlashAttention Support for FlashAttention è una funzionalità della libreria applicabile solo al modello di trasformatore *distribuito, che è un modello Transformer* integrato [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel)per l'addestramento in parallelo al modello. Questa funzionalità è compatibile anche con [Parallelismo tensoriale](model-parallel-extended-features-pytorch-tensor-parallelism.md). La [FlashAttention](https://github.com/HazyResearch/flash-attention)libreria supporta i modelli solo quando `attention_head_size` è impostata su un valore che è un multiplo di 8 e inferiore a 128. Pertanto, quando si addestra un trasformatore distribuito e ci si assicura che FlashAttention funzioni correttamente, è necessario regolare i parametri per fare in modo che la dimensione della testina di attenzione soddisfi i requisiti. Per ulteriori informazioni, consulta anche [Installazione e funzionalità](https://github.com/HazyResearch/flash-attention#installation-and-features) nel *FlashAttention GitHubrepository*. Ad esempio, supponiamo di configurare un modello Transformer con `hidden_width=864` e `num_heads=48`. La dimensione della testa di FlashAttention è calcolata come`attention_head_size = hidden_width / num_heads = 864 / 48 = 18`. Per abilitarlo FlashAttention, è necessario regolare il `num_heads` parametro su`54`, in modo che `attention_head_size = hidden_width / num_heads = 864 / 54 = 16` sia un multiplo di 8. # Esegui un job di formazione SageMaker distribuito con Model Parallelism Scopri come eseguire un processo di formazione parallelo al modello del tuo script di formazione utilizzando SageMaker Python SDK con la libreria di parallelismo dei modelli. SageMaker Esistono tre scenari di utilizzo per l'esecuzione di un processo di formazione. SageMaker 1. Puoi utilizzare uno dei AWS Deep Learning Container predefiniti per e. TensorFlow PyTorch Questa opzione è consigliata se è la prima volta che utilizzi la libreria di parallelizzazione dei modelli. Per trovare un tutorial su come eseguire un processo di formazione parallela su SageMaker modelli, consulta gli esempi di notebook in training [PyTorch with model parallelism library di Amazon SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel). 1. Puoi estendere i contenitori predefiniti per gestire eventuali requisiti funzionali aggiuntivi per il tuo algoritmo o modello che l'immagine Docker predefinita SageMaker non supporta. Per un esempio di come è possibile estendere un container predefinito, consulta [Estensione di un container predefinito](prebuilt-containers-extend.md). 1. [Puoi adattare il tuo contenitore Docker per lavorare con l' SageMaker intelligenza artificiale utilizzando il toolkit di formazione. SageMaker ](https://github.com/aws/sagemaker-training-toolkit) Per un esempio, consulta [Adapting your own training container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html). Per le opzioni 2 e 3 nell'elenco precedente, consulta [Estendi un contenitore Docker predefinito che contiene la libreria parallela SageMaker di modelli distribuiti](model-parallel-sm-sdk.md#model-parallel-customize-container) per informazioni su come installare la libreria di parallelismo dei modelli in un container Docker esteso o personalizzato. In tutti i casi, avviate il processo di formazione configurando un estimatore SageMaker `TensorFlow` o uno `PyTorch` stimatore per attivare la libreria. Per ulteriori informazioni, consulta i seguenti argomenti. **Topics** + [Passaggio 1: modifica il tuo script di addestramento utilizzando SageMaker la libreria parallela di modelli distribuiti](model-parallel-customize-training-script.md) + [Fase 2: Avviare un job di formazione utilizzando SageMaker Python SDK](model-parallel-sm-sdk.md) # Passaggio 1: modifica il tuo script di addestramento utilizzando SageMaker la libreria parallela di modelli distribuiti Utilizza questa sezione per scoprire come personalizzare lo script di formazione per utilizzare le funzionalità principali della libreria di parallelismo dei modelli Amazon SageMaker AI. *Per utilizzare le funzioni e i parametri API specifici della libreria, ti consigliamo di utilizzare questa documentazione insieme alla [libreria model SageMaker parallel APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) nella documentazione di Python SageMaker SDK.* Gli esempi di script di addestramento forniti in queste sezioni sono semplificati e progettati per evidenziare le modifiche necessarie da apportare per utilizzare la libreria. Per end-to-end esempi di notebook eseguibili che dimostrano come utilizzare uno script di PyTorch addestramento TensorFlow o di addestramento con la libreria Model Parallelism, consulta. SageMaker [Esempi di Amazon SageMaker AI Model Parallelism Library v2](distributed-model-parallel-v2-examples.md) **Topics** + [Dividi il modello del tuo script di addestramento utilizzando la libreria di parallelismo dei modelli SageMaker](#model-parallel-model-splitting-using-smp-lib) + [Modificare uno script di addestramento TensorFlow](model-parallel-customize-training-script-tf.md) + [Modificare uno script PyTorch di addestramento](model-parallel-customize-training-script-pt.md) ## Dividi il modello del tuo script di addestramento utilizzando la libreria di parallelismo dei modelli SageMaker Esistono due modi per modificare lo script di addestramento per configurare la suddivisione dei modelli: suddivisione automatica o suddivisione manuale. ### Suddivisione automatica dei modelli *Quando si utilizza SageMaker la libreria di parallelismo dei modelli, è possibile sfruttare la *suddivisione automatica dei modelli*, nota anche come partizionamento automatico dei modelli.* La libreria utilizza un algoritmo di partizionamento che bilancia la memoria, riduce al minimo la comunicazione tra i dispositivi e ottimizza le prestazioni. È possibile configurare l'algoritmo di partizionamento automatico per ottimizzare la velocità o la memoria. In alternativa, è possibile ricorrere alla suddivisione manuale dei modelli. Consigliamo la suddivisione automatica dei modelli, a meno che non si abbia molta dimestichezza con l'architettura dei modelli e si abbia una buona idea di come partizionare i modelli in modo efficiente. #### Come funziona Il partizionamento automatico avviene durante la prima fase di addestramento, quando viene chiamata per la prima volta la funzione lavorata da `smp.step`. Durante questa chiamata, la libreria costruisce innanzitutto una versione del modello sulla RAM della CPU (per evitare limitazioni di memoria della GPU), quindi analizza il grafico del modello e prende una decisione sul partizionamento. In base a questa decisione, ogni partizione del modello viene caricata su una GPU e solo allora viene eseguita la prima fase. A causa di queste fasi di analisi e partizionamento, la prima fase di addestramento potrebbe richiedere più tempo. In entrambi i framework, la libreria gestisce la comunicazione tra i dispositivi tramite il proprio backend, ottimizzato per l'infrastruttura. AWS Il design della partizione automatica si adatta alle caratteristiche del framework e la libreria esegue il partizionamento al livello di granularità più naturale in ciascun framework. Ad esempio, in TensorFlow, ogni operazione specifica può essere assegnata a un dispositivo diverso, mentre in PyTorch, l'assegnazione viene eseguita a livello di modulo, dove ogni modulo è composto da più operazioni. La sezione seguente esamina le specifiche di design in ciascun framework. ##### Divisione automatica del modello con PyTorch Durante la prima fase di addestramento, la libreria di parallelismo dei modelli esegue internamente una fase di tracciamento che ha lo scopo di realizzare il grafico dei modelli e determinare le forme del tensore e dei parametri. Dopo questa fase di tracciamento, la libreria realizza un albero, costituito dagli oggetti `nn.Module` annidati nel modello, oltre ai dati aggiuntivi raccolti dal tracciamento, come la quantità di dati archiviati `nn.Parameters` e il tempo di esecuzione per ciascuno `nn.Module`. Successivamente, la libreria attraversa questo albero dalla radice ed esegue un algoritmo di partizionamento che assegna ciascun `nn.Module` a un dispositivo, che bilancia il carico computazionale (misurato dal tempo di esecuzione del modulo) e l'uso della memoria (misurato dalla dimensione `nn.Parameter` totale memorizzata e dalle attivazioni). Se più `nn.Modules` condividono lo stesso `nn.Parameter`, questi moduli vengono posizionati sullo stesso dispositivo per evitare di mantenere più versioni dello stesso parametro. Una volta presa la decisione sul partizionamento, i moduli e i pesi assegnati vengono caricati sui rispettivi dispositivi. Per istruzioni su come registrare il `smp.step` decoratore nel copione di PyTorch allenamento, consulta. [Divisione automatica con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16) ##### Divisione automatica del modello con TensorFlow La libreria di parallelismo dei modelli analizza le dimensioni delle variabili addestrabili e la struttura dei grafici e utilizza internamente un algoritmo di partizionamento dei grafici. Questo algoritmo prevede l'assegnazione di un dispositivo per ogni operazione, con l'obiettivo di ridurre al minimo la quantità di comunicazioni necessarie tra i dispositivi, nel rispetto di due vincoli: + Bilanciamento del numero di variabili memorizzate in ogni dispositivo + Bilanciamento del numero di operazioni eseguite in ogni dispositivo Se specifichi `speed` per `optimize` (nei parametri di parallelismo dei modelli in SDK per Python), la libreria tenta di bilanciare il numero di operazioni e gli oggetti `tf.Variable` in ogni dispositivo. Altrimenti, tenta di bilanciare la dimensione totale di `tf.Variables`. Una volta presa la decisione sul partizionamento, la libreria crea una rappresentazione serializzata del grafico secondario che ogni dispositivo deve eseguire e la importa su ogni dispositivo. Durante il partizionamento, la libreria colloca le operazioni che utilizzano la stessa `tf.Variable` e quelle che fanno parte dello stesso livello Keras sullo stesso dispositivo. Rispetta inoltre i vincoli di colocation imposti da. TensorFlow Ciò significa che, ad esempio, se ci sono due livelli Keras che condividono una `tf.Variable`, tutte le operazioni che fanno parte di questi livelli vengono posizionate su un singolo dispositivo. Per istruzioni su come registrare il `smp.step` decoratore nel copione di allenamento, consulta. PyTorch [Divisione automatica con TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-23) ##### Confronto della suddivisione automatica dei modelli tra framework In TensorFlow, l'unità di calcolo fondamentale è a`tf.Operation`, e TensorFlow rappresenta il modello come un grafo aciclico diretto (DAG) di `tf.Operation` s, e quindi la libreria di parallelismo del modello partiziona questo DAG in modo che ogni nodo vada su un dispositivo. È fondamentale che gli oggetti `tf.Operation` siano sufficientemente ricchi di attributi personalizzabili e siano universali, nel senso che è garantito che ogni modello sia costituito di un grafico di tali oggetti. PyTorch d'altra parte, non ha una nozione di funzionamento equivalente sufficientemente ricca e universale. L'unità di calcolo più simile PyTorch che presenta queste caratteristiche è an`nn.Module`, che ha un livello di granularità molto più elevato, ed è per questo che la libreria esegue il partizionamento a questo livello in. PyTorch ### Suddivisione manuale dei modelli Se desideri specificare manualmente come partizionare il modello tra i dispositivi, usa il gestore di contesto `smp.partition`. Per istruzioni sulla modalità di impostazione del gestore di contesto per il partizionamento manuale, consulta le pagine seguenti. + [Divisione manuale con TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-manual) + [Divisione manuale con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16-hvd) Per utilizzare questa opzione dopo aver apportato le modifiche, nel passaggio 2, dovrai impostare `auto_partition` e definire un `default_partition` nella classe di stima del framework dell'SDK Python SageMaker. `False` Qualsiasi operazione che non viene inserita in modo esplicito su una partizione tramite il gestore di contesto `smp.partition` è eseguita su `default_partition`. In questo caso, la logica di suddivisione automatica viene ignorata e ogni operazione viene posizionata in base alle specifiche dell'utente. In base alla struttura del grafico risultante, la libreria di parallelismo dei modelli crea automaticamente una pianificazione di esecuzione in pipeline. # Modificare uno script di addestramento TensorFlow In questa sezione, imparerai come modificare gli script di TensorFlow addestramento per configurare la libreria di parallelismo dei SageMaker modelli per il partizionamento automatico e il partizionamento manuale. Gli esempi scelti comprendono anche un esempio integrato con Horovod per il modello ibrido e il parallelismo dei dati. **Nota** Per scoprire quali TensorFlow versioni sono supportate dalla libreria, consulta. [Framework supportati e Regioni AWS](distributed-model-parallel-support.md) Le modifiche necessarie da apportare allo script di addestramento per utilizzare la libreria sono elencate in [Divisione automatica con TensorFlow](#model-parallel-customize-training-script-tf-23). Per maggiori informazioni su come modificare lo script di addestramento per utilizzare il modello ibrido e il parallelismo dei dati con Horovod, consulta [Suddivisione automatizzata con TensorFlow e Horovod per modelli ibridi e parallelismo dei dati](#model-parallel-customize-training-script-tf-2.3). Se desideri utilizzare il partizionamento manuale, consulta anche [Divisione manuale con TensorFlow](#model-parallel-customize-training-script-tf-manual). I seguenti argomenti mostrano esempi di script di addestramento che è possibile utilizzare per configurare la libreria di parallelismo SageMaker dei modelli per il partizionamento automatico e i modelli di partizionamento manuale. TensorFlow **Nota** Il partizionamento automatico è abilitato come impostazione predefinita. Se non diversamente specificato, gli script di esempio utilizzano il partizionamento automatico. **Topics** + [Divisione automatica con TensorFlow](#model-parallel-customize-training-script-tf-23) + [Suddivisione automatizzata con TensorFlow e Horovod per modelli ibridi e parallelismo dei dati](#model-parallel-customize-training-script-tf-2.3) + [Divisione manuale con TensorFlow](#model-parallel-customize-training-script-tf-manual) + [Funzionalità del framework non supportate](#model-parallel-tf-unsupported-features) ## Divisione automatica con TensorFlow Le seguenti modifiche allo script di addestramento sono necessarie per eseguire un TensorFlow modello con la libreria SageMaker di parallelismo dei modelli: 1. Importa e inizializza la libreria con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init). 1. Definisci un modello Keras ereditandolo da [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html) anziché dalla classe di modelli Keras. Restituisci gli output del modello dal metodo di chiamata dell'oggetto `smp.DistributedModel`. Tieni presente che tutti i tensori restituiti dal metodo di chiamata verranno trasmessi su dispositivi paralleli al modello, con un sovraccarico di comunicazione, quindi non dovrebbe essere restituito alcun tensore che non è necessario al di fuori del metodo di chiamata (come le attivazioni intermedie) . 1. Imposta `drop_remainder=True` nel metodo `tf.Dataset.batch()`. Ciò serve a garantire che la dimensione del batch sia sempre divisibile per il numero di microbatch. 1. Semina le operazioni casuali nella pipeline di dati utilizzando`smp.dp_rank()`, ad esempio, `shuffle(ds, seed=smp.dp_rank())` per garantire la coerenza dei campioni di dati su GPUs cui sono presenti diverse partizioni del modello. 1. Inserisci la logica forward e backward in una funzione a fasi e decorala con `smp.step`. 1. Esegui la post-elaborazione sugli output tra i microbatch utilizzando metodi [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) come `reduce_mean`. La funzione [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init) deve restituire un valore che dipende dall'output di `smp.DistributedModel`. 1. Se è presente una fase di valutazione, inserisci in modo analogo la logica forward all'interno di una funzione decorata `smp.step` e post-elabora gli output utilizzando l'[API `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput). [Per ulteriori informazioni sull'API della libreria SageMaker di parallelismo dei modelli, consulta la documentazione dell'API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) Il seguente script Python è un esempio di script di addestramento dopo l'introduzione delle modifiche. ``` import tensorflow as tf # smdistributed: Import TF2.x API import smdistributed.modelparallel.tensorflow as smp # smdistributed: Initialize smp.init() # Download and load MNIST dataset. (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data( "MNIST-data-%d" % smp.rank() ) x_train, x_test = x_train / 255.0, x_test / 255.0 # Add a channels dimension x_train = x_train[..., tf.newaxis] x_test = x_test[..., tf.newaxis] # smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder # in batching to make sure batch size is always divisible by number of microbatches train_ds = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(10000, seed=smp.dp_rank()) .batch(256, drop_remainder=True) ) # smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API class MyModel(smp.DistributedModel): def __init__(self): super(MyModel, self).__init__() # define layers def call(self, x, training=None): # define forward pass and return the model output model = MyModel() loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam() train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy") # smdistributed: Define smp.step. Return any tensors needed outside @smp.step def get_grads(images, labels): predictions = model(images, training=True) loss = loss_object(labels, predictions) grads = optimizer.get_gradients(loss, model.trainable_variables) return grads, loss, predictions @tf.function def train_step(images, labels): gradients, loss, predictions = get_grads(images, labels) # smdistributed: Accumulate the gradients across microbatches gradients = [g.accumulate() for g in gradients] optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # smdistributed: Merge predictions and average losses across microbatches train_accuracy(labels, predictions.merge()) return loss.reduce_mean() for epoch in range(5): # Reset the metrics at the start of the next epoch train_accuracy.reset_states() for images, labels in train_ds: loss = train_step(images, labels) accuracy = train_accuracy.result() ``` Se hai finito di preparare lo script di addestramento, procedi con [Fase 2: Avviare un job di formazione utilizzando SageMaker Python SDK](model-parallel-sm-sdk.md). Se desideri eseguire un modello ibrido e un processo di addestramento per il parallelismo dei dati, continua con la sezione successiva. ## Suddivisione automatizzata con TensorFlow e Horovod per modelli ibridi e parallelismo dei dati Puoi utilizzare la libreria di parallelismo dei SageMaker modelli con Horovod per il parallelismo ibrido di modelli e dati. Per saperne di più su come la libreria suddivide un modello per il parallelismo ibrido, consulta [PyTorch TensorFlowParallelismo delle pipeline (disponibile per e)](model-parallel-intro.md#model-parallel-intro-pp). In questo passaggio, ci concentriamo su come modificare lo script di addestramento per adattare la libreria di parallelismo dei modelli. SageMaker Per configurare correttamente il proprio script di addestramento per acquisire la configurazione di parallelismo ibrido che sarà impostata in [Fase 2: Avviare un job di formazione utilizzando SageMaker Python SDK](model-parallel-sm-sdk.md), usa le funzioni di supporto della libreria, `smp.dp_rank()` e `smp.mp_rank()`, che rilevano automaticamente rispettivamente la classificazione parallela dei dati e la classificazione parallela dei modelli. Per trovare tutte le primitive MPI supportate dalla libreria, consulta [MPI Basics](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#mpi-basics) nella documentazione di Python SDK. SageMaker Le modifiche richieste nello script sono: + Aggiunta di `hvd.allreduce` + Variabili di trasmissione dopo il primo batch, come richiesto da Horovod + Semina le operazioni di and/or shuffling sharding nella pipeline di dati con. `smp.dp_rank()` **Nota** Quando usi Horovod, non devi chiamare `hvd.init` direttamente nel tuo script di addestramento. Dovrai invece `"horovod"` impostarlo `True` nei parametri dell'SDK `modelparallel` di SageMaker Python in. [Fase 2: Avviare un job di formazione utilizzando SageMaker Python SDK](model-parallel-sm-sdk.md) Ciò consente alla libreria di inizializzare internamente Horovod in base alle assegnazioni dei dispositivi delle partizioni del modello. La chiamata di `hvd.init()` direttamente nello script di addestramento può causare problemi. **Nota** L'utilizzo dell'API `hvd.DistributedOptimizer` direttamente nello script di addestramento potrebbe comportare velocità e prestazioni di addestramento scadenti, poiché l'API inserisce implicitamente l'operazione `AllReduce` all'interno di `smp.step`. Ti consigliamo di utilizzare la libreria di parallelismo dei modelli con Horovod chiamando direttamente `hvd.allreduce` dopo aver chiamato `accumulate()` o `reduce_mean()` sui gradienti restituiti da `smp.step`, come verrà mostrato nell'esempio seguente. [Per saperne di più sull'API della libreria SageMaker di parallelismo dei modelli, consulta la documentazione dell'API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) ``` import tensorflow as tf import horovod.tensorflow as hvd # smdistributed: Import TF2.x API import smdistributed.modelparallel.tensorflow as smp # smdistributed: Initialize smp.init() # Download and load MNIST dataset. (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data( "MNIST-data-%d" % smp.rank() ) x_train, x_test = x_train / 255.0, x_test / 255.0 # Add a channels dimension x_train = x_train[..., tf.newaxis] x_test = x_test[..., tf.newaxis] # smdistributed: Seed the shuffle with smp.dp_rank(), and drop_remainder # in batching to make sure batch size is always divisible by number of microbatches train_ds = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(10000, seed=smp.dp_rank()) .batch(256, drop_remainder=True) ) # smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API class MyModel(smp.DistributedModel): def __init__(self): super(MyModel, self).__init__() # define layers def call(self, x, training=None): # define forward pass and return model outputs model = MyModel() loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam() train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy") # smdistributed: Define smp.step. Return any tensors needed outside @smp.step def get_grads(images, labels): predictions = model(images, training=True) loss = loss_object(labels, predictions) grads = optimizer.get_gradients(loss, model.trainable_variables) return grads, loss, predictions @tf.function def train_step(images, labels, first_batch): gradients, loss, predictions = get_grads(images, labels) # smdistributed: Accumulate the gradients across microbatches # Horovod: AllReduce the accumulated gradients gradients = [hvd.allreduce(g.accumulate()) for g in gradients] optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # Horovod: Broadcast the variables after first batch if first_batch: hvd.broadcast_variables(model.variables, root_rank=0) hvd.broadcast_variables(optimizer.variables(), root_rank=0) # smdistributed: Merge predictions across microbatches train_accuracy(labels, predictions.merge()) return loss.reduce_mean() for epoch in range(5): # Reset the metrics at the start of the next epoch train_accuracy.reset_states() for batch, (images, labels) in enumerate(train_ds): loss = train_step(images, labels, tf.constant(batch == 0)) ``` ## Divisione manuale con TensorFlow Usa i gestori di contesto `smp.partition` per inserire le operazioni in una partizione specifica. Qualsiasi operazione non inserita in alcun contesto `smp.partition` viene inserita in `default_partition`. [Per ulteriori informazioni sull'API della libreria SageMaker di parallelismo dei modelli, consulta la documentazione dell'API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) ``` import tensorflow as tf # smdistributed: Import TF2.x API. import smdistributed.modelparallel.tensorflow as smp # smdistributed: Initialize smp.init() # Download and load MNIST dataset. (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data( "MNIST-data-%d" % smp.rank() ) x_train, x_test = x_train / 255.0, x_test / 255.0 # Add a channels dimension x_train = x_train[..., tf.newaxis] x_test = x_test[..., tf.newaxis] # smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder # in batching to make sure batch size is always divisible by number of microbatches. train_ds = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(10000, seed=smp.dp_rank()) .batch(256, drop_remainder=True) ) # smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API. class MyModel(smp.DistributedModel): def __init__(self): # define layers def call(self, x): with smp.partition(0): x = self.layer0(x) with smp.partition(1): return self.layer1(x) model = MyModel() loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam() train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy") # smdistributed: Define smp.step. Return any tensors needed outside @smp.step def get_grads(images, labels): predictions = model(images, training=True) loss = loss_object(labels, predictions) grads = optimizer.get_gradients(loss, model.trainable_variables) return grads, loss, predictions @tf.function def train_step(images, labels): gradients, loss, predictions = get_grads(images, labels) # smdistributed: Accumulate the gradients across microbatches gradients = [g.accumulate() for g in gradients] optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # smdistributed: Merge predictions and average losses across microbatches train_accuracy(labels, predictions.merge()) return loss.reduce_mean() for epoch in range(5): # Reset the metrics at the start of the next epoch train_accuracy.reset_states() for images, labels in train_ds: loss = train_step(images, labels) accuracy = train_accuracy.result() ``` ## Funzionalità del framework non supportate Le seguenti TensorFlow funzionalità non sono supportate dalla libreria: + `tf.GradientTape()` non è attualmente supportato. Puoi invece usare `Optimizer.get_gradients()` o `Optimizer.compute_gradients()` per calcolare i gradienti. + L'API `tf.train.Checkpoint.restore()` non è attualmente supportata. Per il checkpoint, usa invece `smp.CheckpointManager`, che fornisce la stessa API e funzionalità. Tieni presente che il ripristino dei checkpoint con `smp.CheckpointManager` dovrebbe avvenire dopo la prima fase. # Modificare uno script PyTorch di addestramento In questa sezione, imparerai come modificare gli script di PyTorch addestramento per configurare la libreria di parallelismo dei SageMaker modelli per il partizionamento automatico e il partizionamento manuale. **Nota** Per scoprire quali PyTorch versioni sono supportate dalla libreria, consulta. [Framework supportati e Regioni AWS](distributed-model-parallel-support.md) **Suggerimento** Per alcuni esempi di end-to-end quaderni che dimostrano come utilizzare uno script di PyTorch addestramento con la libreria di parallelismo dei SageMaker modelli, vedete. [Esempi della libreria di parallelismo dei modelli Amazon SageMaker AI v1](distributed-model-parallel-examples.md) Si prega di notare che il partizionamento automatico è abilitato come impostazione predefinita. Se non diversamente specificato, gli script seguenti utilizzano il partizionamento automatico. **Topics** + [Divisione automatica con PyTorch](#model-parallel-customize-training-script-pt-16) + [Divisione manuale con PyTorch](#model-parallel-customize-training-script-pt-16-hvd) + [Considerazioni](#model-parallel-pt-considerations) + [Funzionalità del framework non supportate](#model-parallel-pt-unsupported-features) ## Divisione automatica con PyTorch Le seguenti modifiche allo script di addestramento sono necessarie per eseguire uno script di PyTorch addestramento con la libreria SageMaker di parallelismo dei modelli: 1. Importa e inizializza la libreria con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init). 1. Esegui il wrapping del modello con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel). Tieni presente che tutti i tensori restituiti dal metodo `forward` dell'oggetto `nn.Module` sottostante verranno trasmessi su dispositivi paralleli al modello, con un sovraccarico di comunicazione, quindi non dovrebbe essere restituito alcun tensore che non è necessario al di fuori del metodo di chiamata (come le attivazioni intermedie). **Nota** Per la FP16 formazione, è necessario utilizzare il gestore di contesto [smdistributed.modelparallel.torch.model\$1creation () per avvolgere il modello.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) Per ulteriori informazioni, consulta [FP16 Formazione con Model Parallelism](model-parallel-extended-features-pytorch-fp16.md). 1. Esegui il wrapping dell'ottimizzatore con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer). **Nota** Per FP16 la formazione, è necessario impostare la scalabilità statica o dinamica delle perdite. Per ulteriori informazioni, consulta [FP16 Formazione con Model Parallelism](model-parallel-extended-features-pytorch-fp16.md). 1. Utilizza l'oggetto `DistributedModel` restituito anziché un modello utente. 1. Inserisci la logica forward e backward in una funzione a fasi e decorala con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init). 1. Limita ciascun processo al proprio dispositivo tramite `torch.cuda.set_device(smp.local_rank())`. 1. Sposta i tensori di input sulla GPU utilizzando l'API `.to()` prima della chiamata `smp.step` (vedi esempio sotto riportato). 1. Sostituisci `torch.Tensor.backward` e `torch.autograd.backward` con `DistributedModel.backward`. 1. Esegui la post-elaborazione sugli output tra i microbatch utilizzando metodi [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) come `reduce_mean`. 1. Se è presente una fase di valutazione, inserisci in modo analogo la logica forward all'interno di una funzione decorata `smp.step` e post-elabora gli output utilizzando l'[API `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput). 1. Imposta `drop_last=True` in `DataLoader`. In alternativa, salta manualmente un batch nel ciclo di addestramento se la dimensione del batch non è suddivisibile per il numero di microbatch. [Per ulteriori informazioni sull'API della libreria SageMaker di parallelismo dei modelli, consulta la documentazione dell'API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) ``` import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchnet.dataset import SplitDataset from torchvision import datasets import smdistributed.modelparallel.torch as smp class GroupedNet(nn.Module): def __init__(self): super(GroupedNet, self).__init__() # define layers def forward(self, x): # define forward pass and return model outputs # smdistributed: Define smp.step. Return any tensors needed outside. @smp.step def train_step(model, data, target): output = model(data) loss = F.nll_loss(output, target, reduction="mean") model.backward(loss) return output, loss def train(model, device, train_loader, optimizer): model.train() for batch_idx, (data, target) in enumerate(train_loader): # smdistributed: Move input tensors to the GPU ID used by the current process, # based on the set_device call. data, target = data.to(device), target.to(device) optimizer.zero_grad() # Return value, loss_mb is a StepOutput object _, loss_mb = train_step(model, data, target) # smdistributed: Average the loss across microbatches. loss = loss_mb.reduce_mean() optimizer.step() # smdistributed: initialize the backend smp.init() # smdistributed: Set the device to the GPU ID used by the current process. # Input tensors should be transferred to this device. torch.cuda.set_device(smp.local_rank()) device = torch.device("cuda") # smdistributed: Download only on a single process per instance. # When this is not present, the file is corrupted by multiple processes trying # to download and extract at the same time dataset = datasets.MNIST("../data", train=True, download=False) # smdistributed: Shard the dataset based on data-parallel ranks if smp.dp_size() > 1: partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())} dataset = SplitDataset(dataset, partitions=partitions_dict) dataset.select(f"{smp.dp_rank()}") # smdistributed: Set drop_last=True to ensure that batch size is always divisible # by the number of microbatches train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True) model = GroupedNet() optimizer = optim.Adadelta(model.parameters(), lr=4.0) # smdistributed: Use the DistributedModel container to provide the model # to be partitioned across different ranks. For the rest of the script, # the returned DistributedModel object should be used in place of # the model provided for DistributedModel class instantiation. model = smp.DistributedModel(model) optimizer = smp.DistributedOptimizer(optimizer) train(model, device, train_loader, optimizer) ``` ## Divisione manuale con PyTorch Usa i gestori di contesto [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer) per posizionare i moduli in dispositivi specifici. Qualsiasi modulo non inserito in alcun contesto `smp.partition` viene inserito in `default_partition`. Deve essere indicata `default_partition` se `auto_partition` è impostata su `False`. I moduli creati in un contesto `smp.partition` specifico vengono posizionati nella partizione corrispondente. [Per ulteriori informazioni sull'API della libreria SageMaker di parallelismo dei modelli, consulta la documentazione dell'API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) ``` import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchnet.dataset import SplitDataset from torchvision import datasets import smdistributed.modelparallel.torch as smp class GroupedNet(nn.Module): def __init__(self): super(GroupedNet, self).__init__() with smp.partition(0): # define child modules on device 0 with smp.partition(1): # define child modules on device 1 def forward(self, x): # define forward pass and return model outputs # smdistributed: Define smp.step. Return any tensors needed outside. @smp.step def train_step(model, data, target): output = model(data) loss = F.nll_loss(output, target, reduction="mean") model.backward(loss) return output, loss def train(model, device, train_loader, optimizer): model.train() for batch_idx, (data, target) in enumerate(train_loader): # smdistributed: Move input tensors to the GPU ID used by the current process, # based on the set_device call. data, target = data.to(device), target.to(device) optimizer.zero_grad() # Return value, loss_mb is a StepOutput object _, loss_mb = train_step(model, data, target) # smdistributed: Average the loss across microbatches. loss = loss_mb.reduce_mean() optimizer.step() # smdistributed: initialize the backend smp.init() # smdistributed: Set the device to the GPU ID used by the current process. # Input tensors should be transferred to this device. torch.cuda.set_device(smp.local_rank()) device = torch.device("cuda") # smdistributed: Download only on a single process per instance. # When this is not present, the file is corrupted by multiple processes trying # to download and extract at the same time dataset = datasets.MNIST("../data", train=True, download=False) # smdistributed: Shard the dataset based on data-parallel ranks if smp.dp_size() > 1: partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())} dataset = SplitDataset(dataset, partitions=partitions_dict) dataset.select(f"{smp.dp_rank()}") # smdistributed: Set drop_last=True to ensure that batch size is always divisible # by the number of microbatches train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True) model = GroupedNet() optimizer = optim.Adadelta(model.parameters(), lr=4.0) # smdistributed: Use the DistributedModel container to provide the model # to be partitioned across different ranks. For the rest of the script, # the returned DistributedModel object should be used in place of # the model provided for DistributedModel class instantiation. model = smp.DistributedModel(model) optimizer = smp.DistributedOptimizer(optimizer) train(model, device, train_loader, optimizer) ``` ## Considerazioni Quando configurate uno script di PyTorch addestramento utilizzando SageMaker la libreria di parallelismo dei modelli, dovete tenere presente quanto segue: + Se utilizzi una tecnica di ottimizzazione che si basa su norme riguardanti i gradienti globali, ad esempio una norma sui gradienti di tutto il modello, come alcune varianti dell'ottimizzatore LAMB o il ritaglio del gradiente globale, è necessario raccogliere tutte le norme delle partizioni del modello per verificarne la correttezza. A tale scopo è possibile utilizzare i tipi di dati di base per la comunicazione della libreria. + Tutti gli argomenti `torch.Tensor` relativi ai metodi forward di `nn.Modules` nel modello devono essere utilizzati nel calcolo dell'output del modulo. In altre parole, la libreria non supporta il caso in cui esista un argomento `torch.Tensor` per un modulo da cui l'output del modulo non dipende. + L'argomento della chiamata `smp.DistributedModel.backward()` deve dipendere da tutti gli output del modello. In altre parole, non può esserci un output della chiamata `smp.DistributedModel.forward` che non venga utilizzato nel calcolo del tensore utilizzato per la chiamata `smp.DistributedModel.backward`. + Se nel codice sono presenti chiamate `torch.cuda.synchronize()`, potrebbe essere necessario chiamare `torch.cuda.set_device(smp.local_rank())` immediatamente prima della chiamata di sincronizzazione. Altrimenti potrebbero essere creati contesti CUDA non necessari nel dispositivo 0, che consumerebbe inutilmente memoria. + Poiché la libreria colloca `nn.Modules` su dispositivi diversi, i moduli nel modello non devono dipendere da alcuno stato globale modificato all'interno `smp.step`. È consentito qualsiasi stato che rimanga fisso durante l'addestramento o che venga modificato all'esterno di `smp.step` in modo visibile a tutti i processi. + Non è necessario spostare il modello nella GPU (ad esempio, utilizzando `model.to(device)`) quando si utilizza la libreria. Se provi a spostare il modello nella GPU prima che il modello sia partizionato (prima della prima chiamata `smp.step`), la chiamata di spostamento viene ignorata. La libreria sposta automaticamente la parte del modello assegnato a una classificazione nella sua GPU. Una volta iniziato l'addestramento con la libreria, non spostare il modello nella CPU e usalo, poiché non avrà i parametri corretti per i moduli non assegnati alla partizione tenuta dal processo. Se desideri riqualificare un modello o utilizzarlo per l'inferenza senza la libreria dopo che è stato addestrato utilizzando la libreria di parallelismo dei modelli, il modo consigliato è salvare il modello completo utilizzando la nostra API di checkpointing e caricarlo di nuovo su un normale Module. PyTorch + Se disponi di un elenco di moduli tale per cui l'output di un modulo ne alimenta un altro, la sostituzione di tale elenco con `nn.Sequential` può migliorare significativamente le prestazioni. + L'aggiornamento del peso (`optimizer.step()`) deve avvenire all'esterno di `smp.step` perché è allora che l'intero passaggio indietro è terminato e i gradienti sono pronti. Quando si utilizza un modello ibrido con parallelismo di modelli e dati, a questo punto è garantito anche il completamento dei gradienti AllReduce . + Quando usi la libreria in combinazione con il parallelismo dei dati, assicurati che il numero di batch su tutti i ranghi paralleli dei dati sia lo stesso in modo da AllReduce non bloccare l'attesa di un rank che non partecipa al passaggio. + Se avvii un processo di addestramento utilizzando un tipo di istanza ml.p4d (ad esempio ml.p4d.24xlarge), è necessario impostare la variabile del caricatore di dati `num_workers=0`. Ad esempio, puoi definire il tuo `DataLoader` come di seguito indicato: ``` dataloader = torch.utils.data.DataLoader( data, batch_size=batch_size, num_workers=0, pin_memory=True, drop_last=True, shuffle=shuffle, ) ``` + Gli input per `smp.step` devono essere gli input del modello generati da `DataLoader`. Ciò è necessario perché `smp.step` suddivide internamente i tensori di input lungo la dimensione del batch e li inserisce in pipeline. Di conseguenza, passare `DataLoader` alla funzione `smp.step` per generare gli input del modello all'interno non funziona. Ad esempio, se definisci un `DataLoader` come di seguito indicato: ``` train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True) ``` Dovresti accedere agli input del modello generati da `train_loader` e passarli a una funzione decorata `smp.step`. Non passare `train_loader` direttamente alla funzione `smp.step`. ``` def train(model, device, train_loader, optimizer): model.train() for batch_idx, (data, target) in enumerate(train_loader): ... _, loss_mb = train_step(model, data, target) ... @smp.step def train_step(model, data, target): ... return output, loss ``` + I tensori di input per `smp.step` devono essere spostati sul dispositivo attuale utilizzando l'API `.to()`, che deve avvenire dopo la chiamata `torch.cuda.set_device(local_rank())`. Ad esempio, puoi definire la funzione `train` nel modo seguente. Questa funzione aggiunge `data` e `target` al dispositivo attuale utilizzando l'API `.to()` prima di utilizzare i tensori di input per chiamare `train_step`. ``` def train(model, device, train_loader, optimizer): model.train() for batch_idx, (data, target) in enumerate(train_loader): # smdistributed: Move input tensors to the GPU ID used by the current process, # based on the set_device call. data, target = data.to(device), target.to(device) optimizer.zero_grad() # Return value, loss_mb is a StepOutput object _, loss_mb = train_step(model, data, target) # smdistributed: Average the loss across microbatches. loss = loss_mb.reduce_mean() optimizer.step() ``` I tensori di input per questa funzione decorata `smp.set` sono stati spostati nel dispositivo attuale nella funzione `train` sopra riportata. *Non* è necessario spostare il modello nel dispositivo corrente. La libreria sposta automaticamente la parte del modello assegnato a una classificazione nella sua GPU. ``` @smp.step def train_step(model, data, target): output = model(data) loss = F.nll_loss(output, target, reduction="mean") model.backward(loss) return output, loss ``` ## Funzionalità del framework non supportate Le seguenti PyTorch funzionalità non sono supportate dalla SageMaker libreria di parallelismo dei modelli: + Se si utilizza il parallelismo dei dati con il [PyTorch DDP](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) nativo, il modulo [https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)wrapper non è supportato dalla libreria. La libreria gestisce internamente l'integrazione con PyTorch DDP, inclusi i parametri broadcast e gradient. AllReduce Quando si utilizza la libreria, i buffer dei moduli vengono trasmessi una sola volta all'inizio dell'addestramento. Se il proprio modello ha buffer di moduli che devono essere sincronizzati tra gruppi paralleli di dati in ogni fase, è possibile farlo tramite l'API `torch.distributed`, utilizzando il gruppo di processi che può essere ottenuto tramite `smp.get_dp_process_group()`. + Per l'addestramento di precisione misto, il modulo `apex.amp` non è supportato. Per utilizzare la libreria con precisione mista automatica si consiglia di utilizzare `torch.cuda.amp`, utilizzando tuttavia `smp.amp.GradScaler` anziché l'implementazione in torch. + `torch.jit.ScriptModules` e `ScriptFunctions` non sono supportati da `smp.DistributedModel`. + `apex`: `FusedLayerNorm`, `FusedAdam`, `FusedLAMB` e `FusedNovoGrad` da `apex` sono supportati. È possibile utilizzare le relative implementazioni della libreria tramite e invece. `smp.optimizers` `smp.nn` APIs # Fase 2: Avviare un job di formazione utilizzando SageMaker Python SDK L'SDK SageMaker Python supporta l'addestramento gestito di modelli con framework ML come e. TensorFlow PyTorch Per avviare un processo di formazione utilizzando uno di questi framework, è necessario definire uno stimatore, uno estimatore o un SageMaker [TensorFlow Estimator](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) SageMaker generico per utilizzare lo SageMaker [PyTorch script](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) di addestramento modificato e la configurazione del [parallelismo](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator) del modello. **Topics** + [PyTorch Utilizzo degli stimatori e SageMaker TensorFlow](#model-parallel-using-sagemaker-pysdk) + [Estendi un contenitore Docker predefinito che contiene la libreria parallela SageMaker di modelli distribuiti](#model-parallel-customize-container) + [Crea il tuo contenitore Docker con la Distributed Model Parallel Library SageMaker](#model-parallel-bring-your-own-container) ## PyTorch Utilizzo degli stimatori e SageMaker TensorFlow Le classi TensorFlow and PyTorch estimator contengono il `distribution` parametro, che è possibile utilizzare per specificare i parametri di configurazione per l'utilizzo di framework di formazione distribuiti. La libreria SageMaker model parallel utilizza internamente MPI per i dati ibridi e il parallelismo dei modelli, pertanto è necessario utilizzare l'opzione MPI con la libreria. Il seguente modello di PyTorch estimatore TensorFlow or mostra come configurare il `distribution` parametro per l'utilizzo della libreria SageMaker model parallel con MPI. ------ #### [ Using the SageMaker TensorFlow estimator ] ``` import sagemaker from sagemaker.tensorflow import TensorFlow smp_options = { "enabled":True, # Required "parameters": { "partitions": 2, # Required "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "horovod": True, # Use this for hybrid model and data parallelism } } mpi_options = { "enabled" : True, # Required "processes_per_host" : 8, # Required # "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none" } smd_mp_estimator = TensorFlow( entry_point="your_training_script.py", # Specify your train script source_dir="location_to_your_script", role=sagemaker.get_execution_role(), instance_count=1, instance_type='ml.p3.16xlarge', framework_version='2.6.3', py_version='py38', distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options }, base_job_name="SMD-MP-demo", ) smd_mp_estimator.fit('s3://my_bucket/my_training_data/') ``` ------ #### [ Using the SageMaker PyTorch estimator ] ``` import sagemaker from sagemaker.pytorch import PyTorch smp_options = { "enabled":True, "parameters": { # Required "pipeline_parallel_degree": 2, # Required "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "ddp": True, } } mpi_options = { "enabled" : True, # Required "processes_per_host" : 8, # Required # "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none" } 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=1, instance_type='ml.p3.16xlarge', framework_version='1.13.1', py_version='py38', distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options }, base_job_name="SMD-MP-demo", ) smd_mp_estimator.fit('s3://my_bucket/my_training_data/') ``` ------ Per abilitare la libreria, è necessario passare i dizionari di configurazione alle `"mpi"` chiavi `"smdistributed"` and tramite l'`distribution`argomento dei costruttori dello estimatore. SageMaker **Parametri di configurazione per il parallelismo dei modelli SageMaker** + Per la chiave `"smdistributed"`, passa un dizionario con la chiave `"modelparallel"` e i seguenti dizionari interni. **Nota** L'utilizzo di `"modelparallel"` e `"dataparallel"` in un unico processo di addestramento non è supportato. + `"enabled"`: obbligatorio Per abilitare il parallelismo dei modelli, imposta `"enabled": True`. + `"parameters"`: obbligatorio Specificate un set di parametri per il parallelismo del SageMaker modello. + Per un elenco completo dei parametri comuni, consulta [Parametri `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) nella documentazione di *SageMaker Python SDK*. Per TensorFlow, vedi [TensorFlow-specific](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters) Parameters. Per PyTorch, vedi [PyTorch-specific](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters) Parameters. + `"pipeline_parallel_degree"` (o `"partitions"` in `smdistributed-modelparallel Per estendere un contenitore precostruito e utilizzare la libreria SageMaker di parallelismo dei modelli, devi utilizzare una delle immagini AWS Deep Learning Containers (DLC) disponibili per o. PyTorch TensorFlow La libreria di parallelismo dei SageMaker modelli è inclusa nelle immagini DLC TensorFlow (2.3.0 e successive) e (1.6.0 e successive) con CUDA PyTorch (). `cuxyz` Per un elenco completo delle immagini dei DLC, consulta Immagini dei [Deep Learning Containers disponibili](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) nel * GitHub repository AWS Deep Learning Containers*. **Suggerimento** Ti consigliamo di utilizzare l'immagine che contiene la versione più recente TensorFlow o di accedere PyTorch alla maggior parte up-to-date della libreria di parallelismo dei SageMaker modelli. Ad esempio, il Dockerfile deve contenere un'istruzione `FROM` simile alla seguente: ``` # Use the SageMaker DLC image URI for TensorFlow or PyTorch FROM aws-dlc-account-id.dkr.ecr.aws-region.amazonaws.com/framework-training:{framework-version-tag} # Add your dependencies here RUN ... ENV PATH="/opt/ml/code:${PATH}" # this environment variable is used by the SageMaker AI container to determine our user code directory. ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code ``` Inoltre, quando si definisce uno PyTorch TensorFlow stimatore OR, è necessario specificarlo `entry_point` per lo script di addestramento. Questo deve essere lo stesso percorso identificato con `ENV SAGEMAKER_SUBMIT_DIRECTORY` nel Dockerfile. **Suggerimento** È necessario inviare questo contenitore Docker ad Amazon Elastic Container Registry (Amazon ECR) e utilizzare l'URI dell'immagine (`image_uri`) per definire uno stimatore per la formazione. SageMaker Per ulteriori informazioni, consulta [Estensione di un container predefinito](prebuilt-containers-extend.md). Dopo aver completato l'hosting del contenitore Docker e aver recuperato l'URI dell'immagine del contenitore, crea un oggetto estimatore come segue. SageMaker `PyTorch` Questo esempio presuppone che tu abbia già definito `smp_options` e `mpi_options`. ``` smd_mp_estimator = Estimator( entry_point="your_training_script.py", role=sagemaker.get_execution_role(), instance_type='ml.p3.16xlarge', sagemaker_session=sagemaker_session, image_uri='your_aws_account_id.dkr.ecr.region.amazonaws.com/name:tag' instance_count=1, distribution={ "smdistributed": smp_options, "mpi": mpi_options }, base_job_name="SMD-MP-demo", ) smd_mp_estimator.fit('s3://my_bucket/my_training_data/') ``` ## Crea il tuo contenitore Docker con la Distributed Model Parallel Library SageMaker Per creare il tuo contenitore Docker per l'addestramento e utilizzare la libreria parallela del SageMaker modello, devi includere le dipendenze corrette e i file binari delle librerie SageMaker parallele distribuite nel tuo Dockerfile. Questa sezione fornisce il set minimo di blocchi di codice da includere per preparare correttamente un ambiente di SageMaker formazione e la libreria parallela del modello nel proprio contenitore Docker. **Nota** Questa opzione Docker personalizzata con la libreria parallel del SageMaker modello come binario è disponibile solo per PyTorch. **Per creare un Dockerfile con il toolkit di SageMaker formazione e la libreria parallela del modello** 1. Inizia con una delle [immagini di base di NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). ``` FROM ``` **Suggerimento** Le immagini ufficiali del AWS Deep Learning Container (DLC) sono create a partire dalle immagini di base di [NVIDIA](https://hub.docker.com/r/nvidia/cuda) CUDA. Ti consigliamo di consultare i [Dockerfile ufficiali di AWS Deep Learning Container PyTorch per](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) scoprire quali versioni delle librerie devi installare e come configurarle. I Dockerfile ufficiali sono completi, testati con benchmark e gestiti dai team di assistenza e di Deep Learning SageMaker Container. Nel link fornito, scegli la PyTorch versione che usi, scegli la cartella CUDA (`cuxyz`) e scegli il Dockerfile che termina con o. `.gpu` `.sagemaker.gpu` 1. Per configurare un ambiente di addestramento distribuito, devi installare software per dispositivi di comunicazione e di rete, come [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), [NVIDIA Collective Communications Library (NCCL)](https://developer.nvidia.com/nccl) e[Open MPI](https://www.open-mpi.org/). A seconda delle versioni PyTorch di CUDA scelte, è necessario installare versioni compatibili delle librerie. **Importante** Poiché la libreria parallela del SageMaker modello richiede la libreria parallela SageMaker dei dati nei passaggi successivi, ti consigliamo vivamente di seguire le istruzioni riportate [Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI](data-parallel-bring-your-own-container.md) per configurare correttamente un ambiente di SageMaker formazione per la formazione distribuita. Per ulteriori informazioni sulla configurazione di EFA con NCCL e Open MPI, consulta [Get Started with EFA and MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) e la [Guida introduttiva a EFA e NCCL](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html). 1. Aggiungete i seguenti argomenti per specificare i pacchetti URLs di formazione SageMaker distribuiti per PyTorch. La libreria parallela del SageMaker modello richiede che la libreria parallela SageMaker dei dati utilizzi il Remote Direct Memory Access (RDMA) tra nodi. ``` ARG SMD_MODEL_PARALLEL_URL=https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.10.0/build-artifacts/2022-02-21-19-26/smdistributed_modelparallel-1.7.0-cp38-cp38-linux_x86_64.whl ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.10.2/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl ``` 1. Installa le dipendenze richieste dalla libreria parallela del SageMaker modello. 1. Installa la libreria [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview). ``` ARG METIS=metis-5.1.0 RUN rm /etc/apt/sources.list.d/* \ && wget -nv http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/${METIS}.tar.gz \ && gunzip -f ${METIS}.tar.gz \ && tar -xvf ${METIS}.tar \ && cd ${METIS} \ && apt-get update \ && make config shared=1 \ && make install \ && cd .. \ && rm -rf ${METIS}.tar* \ && rm -rf ${METIS} \ && rm -rf /var/lib/apt/lists/* \ && apt-get clean ``` 1. Installa la libreria [RAPIDS Memory Manager](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Ciò richiede la versione [CMake](https://cmake.org/)3.14 o successiva. ``` ARG RMM_VERSION=0.15.0 RUN wget -nv https://github.com/rapidsai/rmm/archive/v${RMM_VERSION}.tar.gz \ && tar -xvf v${RMM_VERSION}.tar.gz \ && cd rmm-${RMM_VERSION} \ && INSTALL_PREFIX=/usr/local ./build.sh librmm \ && cd .. \ && rm -rf v${RMM_VERSION}.tar* \ && rm -rf rmm-${RMM_VERSION} ``` 1. Installa la libreria parallela del SageMaker modello. ``` RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL} ``` 1. Installa la libreria parallela di SageMaker dati. ``` RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY} ``` 1. Installa il [toolkit di addestramento sagemaker](https://github.com/aws/sagemaker-training-toolkit). Il toolkit contiene le funzionalità comuni necessarie per creare un contenitore compatibile con la piattaforma di SageMaker formazione e l'SDK SageMaker Python. ``` RUN pip install sagemaker-training ``` 1. Dopo aver finito di creare il Dockerfile, consulta [Adapting your own training container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) per scoprire come creare il container Docker e ospitarlo in Amazon ECR. **Suggerimento** Per informazioni più generali sulla creazione di un Dockerfile personalizzato per l'addestramento nell' SageMaker intelligenza artificiale, consulta [Use](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html) Your Own Training Algorithms. # Checkpoint e ottimizzazione di un modello con il parallelismo dei modelli La libreria di parallelismo dei SageMaker modelli fornisce il checkpoint APIs per salvare lo stato del modello e lo stato dell'ottimizzatore suddivisi in base alle varie strategie di parallelismo del modello e per caricare i checkpoint per l'addestramento continuo da dove si desidera riavviare l'allenamento e perfezionarlo. Supportano APIs anche opzioni per salvare parzialmente o completamente gli stati del modello e dell'ottimizzatore. **Topics** + [Checkpoint di un modello distribuito](#distributed-model-parallel-checkpoint) + [Ottimizzazione di un modello distribuito](#distributed-model-parallel-fine-tuning) ## Checkpoint di un modello distribuito Scegliete uno dei seguenti argomenti in base al framework tra PyTorch TensorFlow e alla versione della libreria di parallelismo dei SageMaker modelli che utilizzate. **Topics** + [Verifica di un PyTorch modello distribuito (per la libreria di parallelismo dei SageMaker modelli v1.10.0 e successive)](#model-parallel-extended-features-pytorch-checkpoint) + [Controllo di un PyTorch modello distribuito (per la libreria di parallelismo dei modelli tra v1.6.0 e SageMaker v1.9.0)](#model-parallel-extended-features-pytorch-saving-loading-checkpoints) + [TensorFlow Checkpoint: un modello distribuito](#distributed-model-parallel-checkpoint-tensorflow) ### Verifica di un PyTorch modello distribuito (per la libreria di parallelismo dei SageMaker modelli v1.10.0 e successive) La libreria di parallelismo dei SageMaker modelli fornisce un checkpoint APIs per salvare e caricare checkpoint completi o parziali dello stato del modello distribuito e del relativo stato dell'ottimizzatore. **Nota** Questo metodo di checkpoint è consigliato se si utilizza la libreria di parallelismo del modello PyTorch v1.10.0 o successiva SageMaker . **Checkpoint parziale** Per salvare i checkpoint di un modello addestrato con il parallelismo del modello, utilizza l'API [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint) con l'opzione checkpointing parziale impostata su true (`partial=True`). Ciò salva ogni partizione del modello singolarmente. Oltre al modello e allo stato dell'ottimizzatore, puoi anche salvare eventuali dati personalizzati aggiuntivi tramite l'argomento `user_content`. Il modello Checkpoint, l'ottimizzatore e il contenuto dell'utente vengono salvati come file separati. La chiamata API `save_checkpoint` crea cartelle di checkpoint nella seguente struttura. ``` - path - ${tag}_partial (folder for partial checkpoints) - model_rankinfo.pt - optimizer_rankinfo.pt - fp16_states_rankinfo.pt - user_content.pt - $tag (checkpoint file for full checkpoints) - user_content_$tag (user_content file for full checkpoints) - newest (a file that indicates the newest checkpoint) ``` Per riprendere l'addestramento da checkpoint parziali, utilizza l'API [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint)con `partial=True` e specifica la directory dei checkpoint e il tag utilizzati durante il salvataggio dei checkpoint parziali. Nota che il caricamento effettivo dei pesi del modello avviene dopo il partizionamento del modello, durante la prima esecuzione della funzione della fase di addestramento `smdistributed.modelparallel.torch.step` decorata. Quando si salva un checkpoint parziale, la libreria salva anche la decisione sulla partizione del modello come file con estensione di file `.pt`. Al contrario, quando si riprende dal checkpoint parziale, la libreria carica insieme i file di decisione sulla partizione. Una volta caricata la decisione sulla partizione, non è possibile modificarla. Il seguente frammento di codice mostra come impostare il checkpoint in uno script di addestramento. APIs PyTorch ``` import smdistributed.modelparallel.torch as smp model = ... model = smp.DistributedModel(model) optimizer = ... optimizer = smp.DistributedOptimizer(optimizer) user_content = ... # additional custom data checkpoint_path = "/opt/ml/checkpoint/model_parallel" # Save a checkpoint. smp.save_checkpoint( path=checkpoint_path, tag=f"total_steps{total_steps}", partial=True, model=model, optimizer=optimizer, user_content=user_content num_kept_partial_checkpoints=5 ) # Load a checkpoint. # This automatically loads the most recently saved checkpoint. smp_checkpoint = smp.resume_from_checkpoint( path=checkpoint_path, partial=True ) ``` **Checkpoint completo** Per salvare l'artefatto finale del modello a scopo di inferenza, utilizza l'API `smdistributed.modelparallel.torch.save_checkpoint` con `partial=False`, che combina le partizioni del modello per creare un singolo artefatto del modello. Nota che questo non combina gli stati dell'ottimizzatore. Per inizializzare l'addestramento con pesi particolari, con un checkpoint completo del modello, puoi utilizzare l'API `smdistributed.modelparallel.torch.resume_from_checkpoint` con `partial=False`. Nota che questo non carica gli stati dell'ottimizzatore. **Nota** Con il parallelismo tensoriale, in generale, `state_dict` deve essere tradotto tra l'implementazione del modello originale e l'implementazione `DistributedModel`. Facoltativamente, puoi fornire la funzione di traduzione `state_dict` come argomento per `smdistributed.modelparallel.torch.resume_from_checkpoint`. Tuttavia, per [Modelli supportati pronti all'uso](model-parallel-extended-features-pytorch-hugging-face.md#model-parallel-extended-features-pytorch-hugging-face-out-of-the-box), la libreria si occupa di questa traduzione automaticamente. Il codice seguente mostra un esempio di come utilizzare il checkpoint APIs per il checkpoint completo di un PyTorch modello addestrato con il parallelismo dei modelli. ``` import smdistributed.modelparallel.torch as smp model = ... model = smp.DistributedModel(model) optimizer = ... optimizer = smp.DistributedOptimizer(optimizer) user_content = ... # additional custom data checkpoint_path = "/opt/ml/checkpoint/model_parallel" # Save a checkpoint. smp.save_checkpoint( path=checkpoint_path, tag=f"total_steps{total_steps}", partial=False, model=model, optimizer=optimizer, user_content=user_content num_kept_partial_checkpoints=5 ) # Load a checkpoint. # This automatically loads the most recently saved checkpoint. smp_checkpoint = smp.resume_from_checkpoint( path=checkpoint_path, partial=False ) ``` ### Controllo di un PyTorch modello distribuito (per la libreria di parallelismo dei modelli tra v1.6.0 e SageMaker v1.9.0) La libreria di parallelismo dei SageMaker modelli fornisce funzioni Python per il salvataggio di checkpoint parziali o completi per i lavori di formazione con parallelismo tensoriale. La procedura seguente mostra come utilizzare [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save) e [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load) per salvare e caricare un checkpoint quando si utilizza il parallelismo tensoriale. **Nota** Questo metodo di checkpoint è consigliato se si utilizza la libreria di parallelismo dei modelli tra la v1.6.0 e la PyTorch [Parallelismo tensoriale](model-parallel-extended-features-pytorch-tensor-parallelism.md) v1.9.0. SageMaker 1. Prepara un oggetto modello ed esegui il wrapping con la funzione wrapper della libreria `smp.DistributedModel()`. ``` model = MyModel(...) model = smp.DistributedModel(model) ``` 1. Prepara un ottimizzatore per il modello. Un set di parametri del modello è un argomento iterabile richiesto dalle funzioni di ottimizzazione. Per preparare un set di parametri del modello, è necessario procedere per assegnare parametri univoci ai singoli modelli. `model.parameters()` IDs Se ci sono parametri duplicati IDs nel parametro iterabile del modello, il caricamento dello stato dell'ottimizzatore checkpointed non riesce. Per creare un iterabile di parametri del modello con un valore univoco IDs per l'ottimizzatore, consultate quanto segue: ``` unique_params = [] unique_params_set = set() for p in model.parameters(): if p not in unique_params_set: unique_params.append(p) unique_params_set.add(p) del unique_params_set optimizer = MyOpt(unique_params, ...) ``` 1. Esegui il wrapping dell'ottimizzatore usando la funzione wrapper della libreria `smp.DistributedOptimizer()`. ``` optimizer = smp.DistributedOptimizer(optimizer) ``` 1. Salva il modello e lo stato dell'ottimizzatore utilizzando [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save). A seconda di come desideri salvare i checkpoint, scegli una delle seguenti due opzioni: + **Opzione 1:** salva un modello parziale su ciascuno `mp_rank` per uno singolo `MP_GROUP`. ``` model_dict = model.local_state_dict() # save a partial model opt_dict = optimizer.local_state_dict() # save a partial optimizer state # Save the dictionaries at rdp_rank 0 as a checkpoint if smp.rdp_rank() == 0: smp.save( {"model_state_dict": model_dict, "optimizer_state_dict": opt_dict}, f"/checkpoint.pt", partial=True, ) ``` Con il parallelismo tensoriale, la libreria salva i file con checkpoint denominati nel seguente formato: `checkpoint.pt_{pp_rank}_{tp_rank}`. **Nota** Con il parallelismo tensoriale, assicurati di impostare l'istruzione if come `if smp.rdp_rank() == 0` anziché `if smp.dp_rank() == 0`. Quando lo stato dell'ottimizzatore è suddiviso con il parallelismo tensoriale, tutte le classificazioni parallele con dati ridotti devono salvare la propria partizione dello stato dell'ottimizzatore. L'utilizzo di un'istruzione *if* errata per il checkpoint potrebbe comportare l'interruzione del processo di addestramento. *Per ulteriori informazioni sull'utilizzo `if smp.dp_rank() == 0` senza parallelismo tensoriale, vedere [Istruzioni generali per il salvataggio e il caricamento nella](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) documentazione di Python SageMaker SDK.* + **Opzione 2: salva il modello completo.** ``` if smp.rdp_rank() == 0: model_dict = model.state_dict(gather_to_rank0=True) # save the full model if smp.rank() == 0: smp.save( {"model_state_dict": model_dict}, "/checkpoint.pt", partial=False, ) ``` **Nota** Per un checkpoint completo: Se imposti `gather_to_rank0=True`, tutte le classificazioni diverse da `0` restituiscono dizionari vuoti. Per il checkpoint completo, puoi solo controllare il modello. Il checkpoint completo degli stati dell'ottimizzatore non è attualmente supportato. Il modello completo deve solo essere salvato in `smp.rank() == 0`. 1. Carica i checkpoint usando [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load). A seconda di come hai fatto il checkpoint della fase precedente, scegli una delle seguenti due opzioni: + **Opzione 1:** carica i checkpoint parziali. ``` checkpoint = smp.load("/checkpoint.pt", partial=True) model.load_state_dict(checkpoint["model_state_dict"], same_partition_load=False) optimizer.load_state_dict(checkpoint["optimizer_state_dict"]) ``` Puoi impostare `same_partition_load=True` in `model.load_state_dict()` per un caricamento più veloce, se sai che la partizione non cambierà. + **Opzione 2:** carica i checkpoint completi. ``` if smp.rdp_rank() == 0: checkpoint = smp.load("/checkpoint.pt", partial=False) model.load_state_dict(checkpoint["model_state_dict"]) ``` La condizione `if smp.rdp_rank() == 0` non è richiesta, ma può aiutare a evitare caricamenti ridondanti tra diversi `MP_GROUP`. Il dizionario completo degli stati dell'ottimizzatore del checkpoint non è attualmente supportato con il parallelismo del tensore. ### TensorFlow Checkpoint: un modello distribuito Per salvare un TensorFlow modello durante l'addestramento con il parallelismo dei modelli, utilizzate le seguenti funzioni fornite dalla libreria di parallelismo dei SageMaker modelli. + [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model) + [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager) ## Ottimizzazione di un modello distribuito L’ottimizzazione deve essere configurata nello script di addestramento. Il seguente frammento di codice mostra una struttura di esempio di uno script di formazione che utilizza la classe [AutoModelForCausalLM](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM) di Hugging Face Transformers con modifiche per la registrazione dei moduli e delle impostazioni per la regolazione fine. `smdistributed.model.parallel.torch` **Nota** [La messa a punto di un trasformatore distribuito (un modello Transformer incluso) con la funzione smp.delayed\$1param\$1initialization attivata richiede la configurazione del processo di fine-tuning con un `smp.DistributedModel()` file system for Lustre.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) FSx Nei casi in cui si desideri ottimizzare un modello su larga scala con l'opzione di inizializzazione ritardata dei parametri, è necessario configurare un file system for Lustre. FSx ``` import argparse from transformers import AutoModelForCausalLM import smdistributed.modelparallel import smdistributed.modelparallel.torch as smp def parse_args(): parser = argparse.ArgumentParser() # set an arg group for model model_grp = parser.add_argument_group( title="model", description="arguments to describe model configuration" ) ... # set up numerous args to parse from the configuration dictionary to the script for training # add arg for activating fine-tuning model_grp.add_argument( "--fine_tune", type=int, default=0, help="Fine-tune model from checkpoint or pretrained model", ) def main(): """Main function to train GPT.""" args = parse_args() ... # parse numerous args if args.fine_tune > 0 and args.delayed_param > 0 and smp.rank() == 0: pretrained_model = AutoModelForCausalLM.from_pretrained( args.model_name or args.model_dir ) model_state_dict = pretrained_model.state_dict() path = os.path.join(args.model_dir, "fullmodel.pt") torch.save(model_state_dict, path) # create a Transformer model and wrap by smp.model_creation() # with options to configure model parallelism parameters offered by SageMaker AI with smp.model_creation( tensor_parallelism=smp.tp_size() > 1 or args.use_distributed_transformer > 0, zero_init=args.use_distributed_transformer == 0, dtype=dtype, distribute_embedding=args.sharded_data_parallel_degree > 1 and smp.tp_size() > 1, use_alibi=args.alibi > 0, attention_in_fp32=args.attention_in_fp32 > 0, fp32_residual_addition=args.residual_addition_in_fp32 > 0, query_key_layer_scaling=args.query_key_layer_scaling > 0 and args.bf16 < 1, fused_softmax=args.fused_softmax > 0, fused_dropout=args.fused_dropout > 0, fused_bias_gelu=args.fused_bias_gelu > 0, flash_attention=args.flash_attention > 0, ): if args.fine_tune > 0 and args.delayed_param == 0: model = AutoModelForCausalLM.from_pretrained( args.model_name or args.model_dir ) else: model = AutoModelForCausalLM.from_config(model_config) # wrap the model by smp.DistributedModel() to apply SageMaker model parallelism model = smp.DistributedModel( model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation ) # wrap the optimizer by smp.DistributedOptimizer() to apply SageMaker model parallelism optimizer= ... # define an optimizer optimizer = smp.DistributedOptimizer( optimizer, static_loss_scale=None, dynamic_loss_scale=True, dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2}, ) # for fine-tuning, use smp.resume_from_checkpoint() to load a pre-trained model if args.fine_tune > 0 and args.delayed_param > 0: smp.resume_from_checkpoint(args.model_dir, tag="fullmodel.pt", partial=False) ``` [https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel/gpt2](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel/gpt2) # Esempi della libreria di parallelismo dei modelli Amazon SageMaker AI v1 Questa pagina fornisce un elenco di blog e notebook Jupyter che presentano esempi pratici di implementazione della libreria di parallelismo dei SageMaker modelli (SMP) v1 per eseguire lavori di formazione distribuiti sull'intelligenza artificiale. SageMaker ## Blog e casi di studio I seguenti blog illustrano casi di studio relativi all’utilizzo di SMP v1. + [Nuovi miglioramenti delle prestazioni nella libreria di parallelismo dei modelli Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/), *AWS Machine Learning Blog* (16 dicembre 2022) + [Addestra modelli giganteschi con scalabilità quasi lineare utilizzando il parallelismo dei dati frammentati su Amazon AI, SageMaker Machine](https://aws.amazon.com/blogs/machine-learning/train-gigantic-models-with-near-linear-scaling-using-sharded-data-parallelism-on-amazon-sagemaker/) Learning Blog (31 *AWS ottobre* 2022) ## Notebook di esempio [I taccuini di esempio sono disponibili nell'archivio degli esempi di intelligenza artificiale. SageMaker GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/training/distributed_training/) Per scaricare gli esempi, esegui il comando seguente per clonare il repository e accedere a `training/distributed_training/pytorch/model_parallel`. **Nota** Clona ed esegui i taccuini di esempio nel seguente AI ML. SageMaker IDEs [SageMaker JupyterLab](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-jl.html)(disponibile in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creato dopo dicembre 2023) [SageMaker Code Editor](https://docs.aws.amazon.com/sagemaker/latest/dg/code-editor.html) (disponibile in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creato dopo dicembre 2023) [Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) (disponibile come applicazione in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creata dopo dicembre 2023) [SageMaker Istanze Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) ``` git clone https://github.com/aws/amazon-sagemaker-examples.git cd amazon-sagemaker-examples/training/distributed_training/pytorch/model_parallel ``` **Notebook di esempio SMP v1 per PyTorch** + [Addestra GPT-2 con scalabilità quasi lineare utilizzando la tecnica del parallelismo dei dati condivisi nella libreria di parallelismo dei modelli SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-train-gpt-sharded-data-parallel.ipynb) + [Ottimizza GPT-2 con scalabilità quasi lineare utilizzando la tecnica del parallelismo dei dati frammentati nella libreria di parallelismo dei modelli SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-fine-tune-gpt-sharded-data-parallel.ipynb) + [Addestra GPT-NeOX-20b con una scalabilità quasi lineare utilizzando la tecnica del parallelismo dei dati condiviso nella libreria di parallelismo dei modelli SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-neox/smp-train-gpt-neox-sharded-data-parallel.ipynb) + [Addestra GPT-J 6B utilizzando le tecniche di parallelismo dei dati frammentati e parallelismo tensoriale nella libreria di parallelismo dei modelli SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-j/smp-train-gptj-sharded-data-parallel-tp.ipynb) + [Addestra FLAN-T5 con una scalabilità quasi lineare utilizzando la tecnica del parallelismo dei dati frammentati nella libreria di parallelismo dei modelli SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/flan-t5/smp-train-t5-sharded-data-parallel.ipynb) + [Addestra Falcon con una scalabilità quasi lineare utilizzando la tecnica del parallelismo dei dati frammentati nella libreria di parallelismo dei modelli SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/falcon/smp-train-falcon-sharded-data-parallel.ipynb) **Notebook di esempio SMP v1 per TensorFlow** + [CNN con TensorFlow 2.3.1 e la libreria di parallelismo dei modelli SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/model_parallel/mnist/tensorflow_smmodelparallel_mnist.html) + [HuggingFace con la libreria di parallelismo dei modelli TensorFlow distribuiti Training on AI SageMaker ](https://github.com/huggingface/notebooks/blob/master/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb) # SageMaker Best practice per il parallelismo dei modelli distribuiti Utilizza le seguenti linee guida quando esegui un processo di formazione distribuito con la libreria SageMaker model parallel. ## Impostazione della configurazione corretta per un determinato modello Quando si ridimensiona un modello, si consiglia di consultare il seguente elenco in ordine. Ogni voce dell'elenco illustra i vantaggi dell'utilizzo delle tecniche della libreria insieme ai compromessi che potrebbero sorgere. **Suggerimento** Se un modello può adattarsi bene utilizzando un sottoinsieme delle funzionalità della libreria, l'aggiunta di ulteriori funzionalità di parallelismo del modello o di risparmio di memoria di solito non migliora le prestazioni. **Utilizzo di tipi di istanze GPU di grandi dimensioni** + Nell'ambito del parallelismo dei modelli, è preferibile utilizzare istanze potenti con memorie GPU di grandi dimensioni per gestire il sovraccarico dovuto alle operazioni di parallelismo dei modelli, come il partizionamento dei modelli su più modelli. GPUs Consigliamo di utilizzare le nostre istanze `ml.p4d` o `ml.p3dn` per addestrare modelli DL di grandi dimensioni. Queste istanze sono inoltre dotate di Elastic Fabric Adapter (EFA), che fornisce una maggiore larghezza di banda di rete e consente un addestramento su larga scala con parallelismo dei modelli. **Ripartizione dello stato dell'ottimizzatore** + L'impatto dello stato dell'ottimizzatore di ripartizione dipende dal numero di ranghi paralleli dei dati. In genere, un grado più elevato di parallelismo dei dati (proporzionale alla dimensione del nodo di calcolo) può migliorare l'efficienza dell'utilizzo della memoria. Quando desideri ridimensionare un cluster, assicurati di controllare la configurazione dello stato di ripartizione dell'ottimizzatore. Ad esempio, un modello DL di grandi dimensioni con ripartizione dello stato dell'ottimizzatore che si adatta a un cluster di elaborazione con 16 GPUs (ad esempio, due istanze P4d o P4de) potrebbe non adattarsi sempre a un nodo con 8 GPUs (ad esempio, una singola istanza P4d o P4de). Questo perché la memoria combinata di 8 GPUs è inferiore alla memoria combinata di 16 GPUs e la memoria richiesta per GPU per lo sharding di oltre 8 GPUs è anche superiore alla memoria per GPU per lo sharding nello scenario a 16 GPU. Di conseguenza, l'aumento del fabbisogno di memoria potrebbe non essere adatto al cluster più piccolo. Per ulteriori informazioni, consulta [Partizione dello stato dell'ottimizzatore](model-parallel-extended-features-pytorch-optimizer-state-sharding.md). **Checkpoint di attivazione** + L'efficienza della memoria può essere migliorata utilizzando il checkpoint di attivazione per un gruppo di moduli. Più si raggruppano i moduli, più efficiente è l'utilizzo della memoria. Quando si effettuano il checkpoint dei moduli sequenziali per i livelli, l'argomento `strategy` della funzione `smp.set_activation_checkpointing` raggruppa i livelli per il checkpoint. Ad esempio, il raggruppamento di due o più livelli per il checkpoint è più efficiente in termini di memoria rispetto al checkpoint di un livello alla volta, e ciò consente di rinunciare a un tempo di calcolo aggiuntivo con un utilizzo ridotto della memoria. Per ulteriori informazioni, consulta [Checkpoint di attivazione](model-parallel-extended-features-pytorch-activation-checkpointing.md). **Parallelizzazione tensoriale** + Il grado di parallelismo tensoriale deve essere una potenza di due (2, 4, 8,..., 2 n), dove il grado massimo deve essere uguale al numero di per nodo. GPUs Ad esempio, se si utilizza un nodo con 8 GPUs, i numeri possibili per il grado di parallelismo tensoriale sono 2, 4 e 8. Non consigliamo numeri arbitrari (come 3, 5, 6 e 7) per il grado di parallelismo tensoriale. Quando si utilizzano più nodi, una configurazione errata del grado di parallelismo tensoriale potrebbe comportare l'esecuzione del parallelismo tensoriale tra i nodi. Ciò comporta un notevole sovraccarico derivante dalla comunicazione delle attivazioni tra i nodi e può diventare costoso dal punto di vista computazionale. Per ulteriori informazioni, consulta [Parallelismo tensoriale](model-parallel-extended-features-pytorch-tensor-parallelism.md). **Parallelismo delle pipeline tra i nodi** + È possibile eseguire il parallelismo delle pipeline sia all'interno di un singolo nodo che su più nodi. Quando utilizzi il parallelismo delle pipeline in combinazione con il parallelismo tensoriale, ti consigliamo di eseguire il parallelismo della pipeline su più nodi e di mantenere il parallelismo tensoriale all'interno dei singoli nodi. + Il parallelismo della pipeline viene fornito con le seguenti tre manopole: `microbatches`, `active_microbatches` e `prescaled_batch`. + Quando si utilizza il parallelismo tensoriale con il parallelismo della pipeline, si consiglia di attivare `prescaled_batch` modo da aumentare la dimensione del batch per gruppo parallelo del modello per una pipeline efficiente. Con `prescaled_batch` attivato, la dimensione del batch impostata nello script di addestramento diventa `tp_size` moltiplicata per la dimensione del batch impostata per ogni classificazione senza `prescaled_batch`. + L'aumento del numero di `microbatches` consente di ottenere una pipelining efficiente e prestazioni migliori. Si noti che la dimensione effettiva dei microbatch è la dimensione del batch divisa per il numero di microbatch. Se si aumenta il numero di microbatch mantenendo costante la dimensione del batch, ogni microbatch elabora un numero inferiore di campioni. + Il numero di `active_microbatches` è il numero massimo di microbatch che vengono processati contemporaneamente durante la pipeline. Per ogni microbatch attivo in corso, le relative attivazioni e i gradienti occupano la memoria della GPU. Pertanto, l'aumento di `active_microbatches` richiede più memoria GPU. + Se sia la memoria della GPU che quella della GPU sono sottoutilizzate, aumenta `active_microbatches` per una migliore parallelizzazione durante la pipeline. + Per ulteriori informazioni su come utilizzare il parallelismo tensoriale con il parallelismo della pipeline, consulta [Parallelismo tensoriale combinato con parallelismo di pipeline](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism). + Per trovare le descrizioni dei parametri sopra menzionati, consulta [Parameters for `smdistributed` nella documentazione](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed) di *SageMaker Python* SDK. **Trasferimento delle attivazioni sulla CPU** + Assicurati che venga utilizzato in combinazione con il checkpoint di attivazione e il parallelismo della pipeline. Per garantire che l'offload e il preload avvengano in background, specifica un valore maggiore di 1 per il parametro microbatch. + Durante lo scaricamento delle attivazioni, è possibile aumentare `active_microbatches` e talvolta far corrispondere il numero totale di microbatch. Ciò dipende da quali moduli sono sottoposti a checkpoint e da come è partizionato il modello. Per ulteriori informazioni, consulta [Offload di attivazione](model-parallel-extended-features-pytorch-activation-offloading.md). ### Configurazioni di riferimento Il team di formazione sul parallelismo dei SageMaker modelli fornisce i seguenti punti di riferimento basati su esperimenti con il modello GPT-2, sulla lunghezza della sequenza di 512 e sulla dimensione del vocabolario di 50.000. | Il numero di parametri del modello | Tipo di istanza | Parallelismo della pipeline | Parallelismo tensoriale | Ripartizione dello stato dell'ottimizzatore | Checkpoint di attivazione | Batch pre-ridimensionato | Dimensione batch | | --- | --- | --- | --- | --- | --- | --- | --- | | 10 miliardi | 16 ml.p4d.24xlarge | 1 | 4 | True | Ogni livello del trasformatore | True | batch\$1size=40 | | 30 miliardi | 16 ml.p4d.24xlarge | 1 | 8 | True | Ogni livello del trasformatore | True | batch\$1size=32 | | 60 miliardi | 32 ml.p4d.24xlarge | 2 | 8 | True | Ogni livello del trasformatore | True | batch\$1size=56, microbatches=4, active\$1microbatches=2 | È possibile estrapolare le configurazioni precedenti per stimare l'utilizzo della memoria GPU per la configurazione del modello. Ad esempio, se aumenti la lunghezza della sequenza per un modello da 10 miliardi di parametri o aumenti le dimensioni del modello a 20 miliardi, potresti voler ridurre prima la dimensione del batch. Se il modello continua a non adattarsi, prova ad aumentare il grado di parallelismo tensoriale. ## Modifica dello script di addestramento + Prima di utilizzare le funzionalità della libreria SageMaker model parallel nello script di addestramento, rivedi[Suggerimenti e insidie per la configurazione della SageMaker Distributed Model Parallelism Library](model-parallel-customize-tips-pitfalls.md). + Per avviare più rapidamente un processo di formazione, utilizza la [modalità locale SageMaker AI](https://sagemaker.readthedocs.io/en/v2.199.0/overview.html?highlight=local%20mode#local-mode). Ciò consente di eseguire rapidamente un processo di formazione localmente su un'istanza di SageMaker notebook. A seconda della scala dell'istanza di ML su cui è in esecuzione l'istanza del SageMaker notebook, potrebbe essere necessario regolare le dimensioni del modello modificando le configurazioni del modello, ad esempio la larghezza nascosta, il numero di livelli del trasformatore e le testine di attenzione. Verifica se il modello ridotto funziona bene sull'istanza del notebook prima di utilizzare un cluster di grandi dimensioni per addestrare il modello completo. ## Monitoraggio e registrazione di un lavoro di formazione utilizzando la console SageMaker AI e Amazon CloudWatch [Per monitorare metriche a livello di sistema come l'utilizzo della memoria CPU, l'utilizzo della memoria GPU e l'utilizzo della GPU, utilizza la visualizzazione fornita tramite la console AI. SageMaker ](https://console.aws.amazon.com/sagemaker/) 1. Nel pannello di navigazione a sinistra scegli **Addestramento**. 1. Scegli **Processi di addestramento**. 1. Nel riquadro principale, scegli il nome del processo di addestramento per il quale desideri visualizzare ulteriori dettagli. 1. Sfoglia il pannello principale e trova la sezione **Monitora** per vedere la visualizzazione automatizzata. 1. Per visualizzare i log dei processi di addestramento , scegli **Visualizza log** nella sezione **Monitora**. È possibile accedere ai registri distribuiti dei lavori di formazione relativi al processo di formazione in. CloudWatch Se hai avviato l’addestramento distribuito su più nodi, dovresti vedere più flussi di log con tag nel formato **algo-n-1234567890**. Il flusso di log **algo-1** tiene traccia dei log di addestramento dal nodo principale (0°). Per ulteriori informazioni, consulta [Amazon CloudWatch Metrics per il monitoraggio e l'analisi dei lavori di formazione](training-metrics.md). ## Permissions Per eseguire un processo di SageMaker formazione con il parallelismo dei modelli o i [notebook di esempio di formazione SageMaker distribuiti](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/index.html), assicurati di disporre delle autorizzazioni giuste nel tuo ruolo IAM, come le seguenti: + [Da usare per Lustre, aggiungi. FSx [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess)](https://aws.amazon.com/fsx/) + Per utilizzare Amazon S3 come canale dati, aggiungi [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess). + Per utilizzare Docker, creare il tuo container e inviarlo ad Amazon ECR, aggiungi [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess). + Per avere accesso completo all'intera suite di funzionalità di SageMaker intelligenza artificiale, aggiungi [https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess). # Suggerimenti e insidie per la configurazione della SageMaker Distributed Model Parallelism Library Esamina i seguenti suggerimenti e insidie prima di utilizzare la libreria di parallelismo dei modelli di Amazon SageMaker AI. Questo elenco include suggerimenti applicabili a tutti i framework. Per TensorFlow suggerimenti PyTorch specifici, consulta [Modificare uno script di addestramento TensorFlow](model-parallel-customize-training-script-tf.md) e[Modificare uno script PyTorch di addestramento](model-parallel-customize-training-script-pt.md), rispettivamente. ## Dimensione del batch e numero di microbatch + La libreria è più efficiente quando la dimensione del batch viene aumentata. Nei casi d'uso in cui il modello si inserisce in un singolo dispositivo, ma può essere addestrato solo con batch di piccole dimensioni, la dimensione del batch può e deve essere aumentata dopo l'integrazione della libreria. Il parallelismo dei modelli consente di risparmiare memoria per i modelli di grandi dimensioni, consentendovi di addestrare utilizzando batch di dimensioni che in precedenza non rientravano nella memoria. + La scelta di un numero di microbatch troppo piccolo o troppo grande può ridurre le prestazioni. La libreria esegue ogni microbatch in sequenza in ogni dispositivo, pertanto la dimensione del microbatch (dimensione del batch divisa per il numero di microbatch) deve essere sufficientemente grande da consentire l'utilizzo completo di ciascuna GPU. Allo stesso tempo, l'efficienza della pipeline aumenta con il numero di microbatch, quindi è importante trovare il giusto equilibrio. In genere, un buon punto di inizio è provare 2 o 4 microbatch, aumentando la dimensione del batch fino al limite di memoria, e quindi sperimentare con batch di dimensioni e numeri di microbatch più grandi. Con l'aumento del numero di microbatch, potrebbero diventare possibili lotti di dimensioni maggiori se si utilizza una pipeline interlacciata. + La dimensione del batch deve essere sempre divisibile per il numero di microbatch. Tieni presente che, a seconda delle dimensioni del set di dati, a volte l'ultimo batch di ogni epoca può avere dimensioni inferiori rispetto al resto e questo batch più piccolo deve essere divisibile anche per il numero di microbatch. `drop_remainder=True`In caso contrario, è possibile impostare la `tf.Dataset.batch()` chiamata (in TensorFlow) o impostare `DataLoader` (`drop_last=True`in PyTorch), in modo che quest'ultimo, piccolo batch non venga utilizzato. Se si utilizza un'API diversa per la pipeline di dati, potrebbe essere necessario saltare manualmente l'ultimo batch ogni volta che non è divisibile per il numero di microbatch. ## Partizionamento manuale + Se utilizzi il partizionamento manuale, tieni presente i parametri utilizzati da più operazioni e moduli del modello, come la tabella di incorporamento nelle architetture dei trasformatori. I moduli che condividono lo stesso parametro devono essere collocati nello stesso dispositivo per motivi di correttezza. Quando viene utilizzato il partizionamento automatico, la libreria applica automaticamente questo vincolo. ## Preparazione dei dati + Se il modello richiede più input, assicurati di impostare le operazioni casuali nella data pipeline (ad esempio, lo shuffling) con `smp.dp_rank()`. Se il set di dati viene suddiviso in modo deterministico su dispositivi di parallelismo dei dati, assicurati che lo shard sia indicizzato da `smp.dp_rank()`. Questo serve a garantire che l'ordine dei dati visualizzati su tutte le classificazioni che formano una partizione del modello sia coerente. ## Restituzione di tensori da `smp.DistributedModel` + Qualsiasi tensore restituito dalla funzione `smp.DistributedModel.call` (for TensorFlow) o `smp.DistributedModel.forward` (for PyTorch) viene trasmesso a tutti gli altri ranghi, dal rango che ha calcolato quel particolare tensore. Di conseguenza, qualsiasi tensore non necessario al di fuori dei metodi call e forward (attivazioni intermedie, ad esempio) non dovrebbe essere restituito, poiché ciò causa inutili comunicazioni e sovraccarico di memoria e danneggia le prestazioni. ## Il decoratore `@smp.step` + Se una funzione `smp.step` decorata ha un argomento di tensore che non ha una dimensione batch, il nome dell'argomento deve essere fornito nell'elenco `non_split_inputs`durante la chiamata `smp.step`. Ciò impedisce alla libreria di tentare di dividere il tensore in microbatch. Per ulteriori informazioni, consulta [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html) nella documentazione API. ## Ritardo dell'inizializzazione dei parametri Per modelli molto grandi con oltre 100 miliardi di parametri, l'inizializzazione del peso tramite la memoria della CPU potrebbe causare un errore. out-of-memory Per ovviare a questo problema, la libreria offre un gestore di contesto `smp.delay_param_initialization`. Ciò ritarda l'allocazione fisica dei parametri fino a quando non passano alla GPU durante la prima esecuzione di una funzione `smp.step` decorata. Ciò evita un utilizzo non necessario della memoria della CPU durante l'inizializzazione dell'addestramento. Utilizza il gestore di contesto quando crei un oggetto modello, come mostrato nel codice seguente. ``` with smp.delay_param_initialization(enabled=True): model = MyModel() ``` ## Tensor Parallelism per PyTorch + Se stai usando un seed per risultati deterministici, imposta il seed in base a `smp.dp_rank()` (ad esempio, `torch.manual_seed(42 + smp.dp_rank())`). Se non effettui questa operazione, diverse partizioni di un `nn.Parameter` vengono inizializzate nello stesso modo, con un impatto sulla convergenza. + SageMakerla libreria di parallelismo dei modelli utilizza NCCL per implementare i collettivi necessari per la distribuzione dei moduli. Soprattutto per i modelli più piccoli, se sulla GPU sono programmate troppe chiamate NCCL contemporaneamente, l'utilizzo della memoria potrebbe aumentare a causa dello spazio aggiuntivo utilizzato da NCCL. Per ovviare a questo problema, `smp` limita le chiamate NCCL in modo che il numero di operazioni NCCL in corso in un dato momento sia inferiore o uguale a un determinato limite. Il limite predefinito è 8, ma può essere regolato utilizzando la variabile di ambiente `SMP_NCCL_THROTTLE_LIMIT`. Se osservi un utilizzo della memoria maggiore del previsto durante l'utilizzo del parallelismo tensoriale, puoi provare a ridurre questo limite. Tuttavia, la scelta di un limite troppo piccolo potrebbe causare una perdita di throughput. Per disabilitare completamente la limitazione, puoi impostare `SMP_NCCL_THROTTLE_LIMIT=-1`. + La seguente identità, che vale quando il grado di parallelismo tensoriale è 1, non vale quando il grado di parallelismo tensoriale è maggiore di 1: `smp.mp_size() * smp.dp_size() == smp.size()`. Questo perché il gruppo parallelo tensoriale fa parte sia del gruppo di parallelismo del modello che del gruppo di parallelismo dei dati. Se il codice contiene riferimenti esistenti a `mp_rank`, `mp_size`, `MP_GROUP` e così via e se desideri lavorare solo con il gruppo pipeline parallel, potrebbe essere necessario sostituire i riferimenti con `smp.pp_size()`. Le seguenti identità sono sempre vere: + `smp.mp_size() * smp.rdp_size() == smp.size()` + `smp.pp_size() * smp.dp_size() == smp.size()` + `smp.pp_size() * smp.tp_size() * smp.rdp_size() == smp.size()` + Poiché il wrapper `smp.DistributedModel` modifica i parametri del modello quando il parallelismo tensoriale è abilitato, l'ottimizzatore deve essere creato dopo la chiamata a `smp.DistributedModel`, con i parametri distribuiti. Ad esempio, quanto segue non funziona: ``` ## WRONG model = MyModel() optimizer = SomeOptimizer(model.parameters()) model = smp.DistributedModel(model)  # optimizer now has outdated parameters!  ``` Invece, l'ottimizzatore dovrebbe essere creato con i seguenti parametri del `smp.DistributedModel`: ``` ## CORRECT model = smp.DistributedModel(MyModel()) optimizer = SomeOptimizer(model.optimizers()) ``` + Quando un modulo viene sostituito con la sua controparte distribuita tramite il parallelismo tensoriale, il modulo distribuito non eredita i suoi pesi dal modulo originale e inizializza nuovi pesi. Ciò significa che, ad esempio, se i pesi devono essere inizializzati in una particolare chiamata (ad esempio, tramite una chiamata `load_state_dict`), ciò deve avvenire dopo la chiamata `smp.DistributedModel`, una volta avvenuta la distribuzione del modulo. + Quando accedi direttamente ai parametri dei moduli distribuiti, tieni presente che il peso non ha la stessa forma del modulo originale. Ad esempio,  ``` with smp.tensor_parallelism():     linear = nn.Linear(60, 60) # will pass assert tuple(linear.weight.shape) == (60, 60) distributed_linear = smp.DistributedModel(linear) # will fail. the number of input channels will have been divided by smp.tp_size() assert tuple(distributed_linear.module.weight.shape) == (60, 60) ``` + L'uso di `torch.utils.data.distributed.DistributedSampler` è fortemente consigliato per il parallelismo tensoriale. Ciò garantisce che ogni classificazione di parallelismo dei dati riceva lo stesso numero di campioni di dati, il che impedisce i blocchi che potrebbero derivare dall'esecuzione di diversi numeri di fasi da parte di diversi `dp_rank`. + Se si utilizza la `DistributedDataParallel` classe `join` API of PyTorch per gestire i casi in cui ranghi paralleli di dati diversi hanno un numero diverso di batch, è comunque necessario assicurarsi che i ranghi che si trovano nello stesso `TP_GROUP` numero di batch; altrimenti i collettivi di comunicazione utilizzati nell'esecuzione distribuita dei moduli potrebbero bloccarsi. Le classificazioni che si trovano in `TP_GROUP` diversi possono avere un numero diverso di batch, purché venga utilizzata l'API `join`. + Se desideri controllare il tuo modello e utilizzare il parallelismo tensoriale, considera quanto segue: + Per evitare situazioni di stallo e condizioni di competizione durante il salvataggio e il caricamento dei modelli quando utilizzi il parallelismo tensoriale, assicurati di richiamare le funzioni appropriate dai seguenti stati del modello e dell'ottimizzatore all'interno di una classificazione di parallelismo dei dati ridotta. + Se stai effettuando la transizione di uno script parallelo di pipeline esistente e abiliti il parallelismo tensoriale per lo script, assicurati di modificare qualsiasi blocco `if smp.dp_rank() == 0` utilizzato per il salvataggio e il caricamento con blocchi `if smp.rdp_rank() == 0`. In caso contrario, il processo di addestramento potrebbe bloccarsi. Per ulteriori informazioni sul checkpoint di un modello con parallelismo tensoriale, consulta [Checkpoint di un modello distribuito](distributed-model-parallel-checkpointing-and-finetuning.md#distributed-model-parallel-checkpoint). # Risoluzione dei problemi del parallelismo dei modelli Se riscontri un errore, puoi utilizzare il seguente elenco per provare a risolvere il tuo processo di addestramento. Se il problema persiste, contatta l’[Assistenza AWS](https://aws.amazon.com/premiumsupport). **Topics** + [Considerazioni sull'utilizzo di SageMaker Debugger con la Model Parallelism Library SageMaker](#distributed-ts-model-parallel-debugger) + [Salvataggio dei checkpoint](#distributed-ts-model-parallel-checkpoints) + [Convergenza utilizzando Model Parallel e TensorFlow](#distributed-ts-model-parallel-tf-convergence) + [Blocco o arresto anomalo dei processi di addestramento distribuiti](#distributed-ts-model-parallel-training-issues) + [Ricezione di un errore NCCL per un job di formazione PyTorch](#distributed-ts-model-parallel-nccl-error) + [Ricezione `RecursionError` per un PyTorch tirocinio](#distributed-ts-model-parallel-super-forward-not-supported) ## Considerazioni sull'utilizzo di SageMaker Debugger con la Model Parallelism Library SageMaker SageMaker Debugger non è disponibile per la libreria di parallelismo dei modelli. SageMaker Il debugger è abilitato per impostazione predefinita per tutti i processi di PyTorch formazione SageMaker TensorFlow e potresti visualizzare un errore simile al seguente: ``` FileNotFoundError: [Errno 2] No such file or directory: '/opt/ml/checkpoints/metadata.json.sagemaker-uploading ``` Per risolvere questo problema, disabilita Debugger passando `debugger_hook_config=False` durante la creazione di un framework `estimator`, come mostrato nell'esempio seguente. ``` bucket=sagemaker.Session().default_bucket() base_job_name="sagemaker-checkpoint-test" checkpoint_in_bucket="checkpoints" # The S3 URI to store the checkpoints checkpoint_s3_bucket="s3://{}/{}/{}".format(bucket, base_job_name, checkpoint_in_bucket) estimator = TensorFlow( ... distribution={"smdistributed": {"modelparallel": { "enabled": True }}}, checkpoint_s3_uri=checkpoint_s3_bucket, checkpoint_local_path="/opt/ml/checkpoints", debugger_hook_config=False ) ``` ## Salvataggio dei checkpoint Potresti riscontrare il seguente errore durante il salvataggio dei checkpoint di un modello di grandi dimensioni su AI: SageMaker ``` InternalServerError: We encountered an internal error. Please try again ``` Ciò potrebbe essere causato da una limitazione dell' SageMaker IA durante il caricamento del checkpoint locale su Amazon S3 durante la formazione. Per disabilitare il checkpoint nell' SageMaker IA, usa il seguente esempio per caricare esplicitamente i checkpoint. Se riscontri l'errore precedente, non utilizzarlo con la chiamata. `checkpoint_s3_uri` SageMaker `estimator` Durante il salvataggio dei checkpoint per modelli più grandi, consigliamo di salvare i checkpoint in una directory personalizzata e di passarli alla funzione di supporto (come argomento `local_path`). ``` import os def aws_s3_sync(source, destination): """aws s3 sync in quiet mode and time profile""" import time, subprocess cmd = ["aws", "s3", "sync", "--quiet", source, destination] print(f"Syncing files from {source} to {destination}") start_time = time.time() p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) p.wait() end_time = time.time() print("Time Taken to Sync: ", (end_time-start_time)) return def sync_local_checkpoints_to_s3(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'): """ sample function to sync checkpoints from local path to s3 """ import boto3 #check if local path exists if not os.path.exists(local_path): raise RuntimeError("Provided local path {local_path} does not exist. Please check") #check if s3 bucket exists s3 = boto3.resource('s3') if not s3_uri.startswith("s3://"): raise ValueError(f"Provided s3 uri {s3_uri} is not valid.") s3_bucket = s3_uri.replace('s3://','').split('/')[0] print(f"S3 Bucket: {s3_bucket}") try: s3.meta.client.head_bucket(Bucket=s3_bucket) except Exception as e: raise e aws_s3_sync(local_path, s3_uri) return def sync_s3_checkpoints_to_local(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'): """ sample function to sync checkpoints from s3 to local path """ import boto3 #try to create local path if it does not exist if not os.path.exists(local_path): print(f"Provided local path {local_path} does not exist. Creating...") try: os.makedirs(local_path) except Exception as e: raise RuntimeError(f"Failed to create {local_path}") #check if s3 bucket exists s3 = boto3.resource('s3') if not s3_uri.startswith("s3://"): raise ValueError(f"Provided s3 uri {s3_uri} is not valid.") s3_bucket = s3_uri.replace('s3://','').split('/')[0] print(f"S3 Bucket: {s3_bucket}") try: s3.meta.client.head_bucket(Bucket=s3_bucket) except Exception as e: raise e aws_s3_sync(s3_uri, local_path) return ``` Utilizzo delle funzioni di supporto: ``` #base_s3_uri - user input s3 uri or save to model directory (default) #curr_host - to save checkpoints of current host #iteration - current step/epoch during which checkpoint is saved # save checkpoints on every node using local_rank if smp.local_rank() == 0: base_s3_uri = os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', ''))) curr_host = os.environ['SM_CURRENT_HOST'] full_s3_uri = f'{base_s3_uri}/checkpoints/{curr_host}/{iteration}' sync_local_checkpoints_to_s3(local_path=checkpoint_dir, s3_uri=full_s3_uri) ``` ## Convergenza utilizzando Model Parallel e TensorFlow Quando si utilizza l' SageMaker intelligenza artificiale multinodo TensorFlow e la libreria di parallelismo dei modelli, la perdita potrebbe non convergere come previsto perché l'ordine dei file di input di addestramento potrebbe essere diverso su ciascun nodo. Ciò può far sì che ranghi diversi nello stesso gruppo parallelo del modello lavorino su file di input diversi, causando incongruenze. Per evitare ciò, assicurati che i file di input siano ordinati allo stesso modo in tutti i ranghi prima che vengano convertiti in set di dati. TensorFlow Un modo per raggiungere questo obiettivo è ordinare i nomi dei file di input nello script di addestramento. ## Blocco o arresto anomalo dei processi di addestramento distribuiti Se il processo di addestramento presenta problemi di blocco, arresto anomalo o mancata risposta, leggi i seguenti articoli per la risoluzione dei problemi per identificare la causa del problema. Se hai bisogno di ulteriore assistenza, contatta il team di formazione SageMaker distribuito tramite [AWS Support](https://aws.amazon.com/premiumsupport). + Se vedi **un processo di addestramento distribuito che si blocca durante la fase di inizializzazione NCCL**, considera quanto segue: + Se utilizzi una delle istanze (istanze `ml.p4d` o `ml.p3dn`) abilitate per EFA con un VPC personalizzato e relativa sottorete, assicurati che il gruppo di sicurezza utilizzato disponga di connessioni in entrata e in uscita per tutte le porte da e verso lo stesso SG. In genere sono inoltre necessarie connessioni in uscita a qualsiasi IP come regola separata (per l'accesso a Internet). Per trovare istruzioni su come aggiungere regole in entrata e in uscita per le comunicazioni EFA, consulta [SageMaker Il processo di formazione distribuito dall'IA si blocca durante l'inizializzazione](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-efa-sg). + Se noti che un **processo di addestramento distribuito si blocca durante il checkpoint** del modello completo, ciò potrebbe essere dovuto al fatto che la chiamata `state_dict()` al modello o all'ottimizzatore non è stata effettuata a tutti i livelli con `rdp_rank()==0` (quando si utilizza il parallelismo tensoriale) o `dp_rank()==0` (quando si utilizza solo il parallelismo delle pipeline). Questi livelli devono comunicare per costruire il checkpoint da salvare. Problemi di stallo simili possono verificarsi anche quando l'ottimizzatore parziale di checkpoint `shard_optimizer_state` è abilitato. Per ulteriori informazioni sul checkpoint di un modello con parallelismo del modello, vedere [Istruzioni generali per il salvataggio e il caricamento](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) e[Controllo di un PyTorch modello distribuito (per la libreria di parallelismo dei modelli tra v1.6.0 e SageMaker v1.9.0)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-saving-loading-checkpoints). + Se il processo di addestramento si blocca con un **errore CUDA Memoria esaurita**, significa che la configurazione di addestramento distribuito deve essere adattata al modello sul cluster GPU. Per ulteriori informazioni e best practice, consulta [Impostazione della configurazione corretta per un determinato modello](model-parallel-best-practices.md#model-parallel-best-practices-configuration). + Se il processo di formazione si blocca con un **[errore ECC](https://docs.nvidia.com/deploy/a100-gpu-mem-error-mgmt/index.html) non correggibile**, significa che uno dei componenti del GPUs cluster non funziona correttamente. Se hai bisogno di supporto tecnico, condividi l'ARN del processo con il AWS team e, se possibile, riavvia il processo di addestramento da un checkpoint. + In rari casi, la configurazione di un processo che funzionava in precedenza ma che è vicina ai limiti della memoria della GPU potrebbe fallire in seguito con un cluster diverso a causa di un **errore CUDA Memoria esaurita**. Ciò potrebbe essere dovuto al fatto che alcune GPU hanno una memoria disponibile inferiore al solito a causa di errori ECC. + Un **arresto anomalo del timeout di rete** potrebbe verificarsi quando si esegue un processo multinodo che non utilizza tutto il nodo. GPUs Per ovviare a questo problema, usa all GPUs on the node assicurandoti che il `processes_per_host` parametro sia impostato sul numero di GPUs in ogni istanza. Ad esempio, questo è `processes_per_host=8` per le istanze `ml.p3.16xlarge`, `ml.p3dn.24xlarge`, e `ml.p4d.24xlarge`. + Se ritieni che il tuo processo di formazione richieda molto tempo durante la fase di download dei dati, assicurati che il percorso Amazon S3 che hai fornito `checkpoint_s3_uri` per il SageMaker `Estimator` corso sia unico per il corso di formazione corrente. Se questo percorso viene riutilizzato in più processi di addestramento eseguiti contemporaneamente, tutti i checkpoint vengono caricati e scaricati sullo stesso percorso Amazon S3 e potrebbero aumentare significativamente il tempo di caricamento dei checkpoint. + Utilizzalo FSx per Lustre quando gestisci dati e modelli di grandi dimensioni. + [Se il set di dati è di grandi dimensioni e il recupero richiede molto tempo, ti consigliamo di conservare il set di dati per Lustre. FSx ](https://aws.amazon.com/fsx/lustre/) + Quando i modelli di addestramento superano i 10 miliardi di parametri, consigliamo di utilizzare Lustre FSx per il checkpoint. + Dopo aver creato un file system, assicurati di attendere che lo status diventi **disponibile** prima di iniziare un processo di addestramento che lo utilizzi. ## Ricezione di un errore NCCL per un job di formazione PyTorch Se hai riscontrato il seguente errore, potrebbe essere dovuto a un processo che sta esaurendo la memoria della GPU. ``` NCCL error in: ../torch/lib/c10d/ProcessGroupNCCL.cpp:825, unhandled system error, NCCL version 2.7.8 ncclSystemError: System call (socket, malloc, munmap, etc) failed. ``` È possibile risolvere questo problema riducendo la dimensione del batch o `active_microbatches`. Se il partizionamento automatico non porta a un partizionamento ben bilanciato, potrebbe essere necessario prendere in considerazione il partizionamento manuale. Per ulteriori informazioni, consulta [Parallelismo delle pipeline tra i nodi](model-parallel-best-practices.md#model-parallel-best-practices-configuration-pipeline-across-nodes). ## Ricezione `RecursionError` per un PyTorch tirocinio La libreria non supporta le chiamate `super.forward()` all'interno della chiamata inoltrata di un modulo. Se utilizzi `super.forward()`, potresti visualizzare il seguente messaggio di errore: ``` RecursionError: maximum recursion depth exceeded ``` Per correggere l'errore, invece di chiamare `super.forward()`, dovresti chiamare `super()._orig_forward()`. # Elaborazione distribuita con best practice di SageMaker intelligenza artificiale Questa pagina delle migliori pratiche presenta vari tipi di calcolo distribuito per i processi di machine learning (ML) in generale. Il termine *calcolo distribuito* in questa pagina comprende l’addestramento distribuito per le attività di machine learning e il calcolo parallelo per l'elaborazione dei dati, la generazione di dati, l'ingegneria delle caratteristiche e l'apprendimento per rinforzo. In questa pagina, discutiamo delle sfide più comuni nel calcolo distribuito e delle opzioni disponibili in SageMaker Training and SageMaker Processing. Per ulteriori materiali di lettura sul calcolo distribuito, consulta [What is Distributed Computing?](https://aws.amazon.com/what-is/distributed-computing/). È possibile configurare le attività di machine learning in modo che vengano eseguite in modo distribuito su più nodi (istanze), acceleratori (chip NVIDIA GPUs, AWS Trainium) e core vCPU. Eseguendo il calcolo distribuito, puoi raggiungere una serie di obiettivi, ad esempio velocizzare le operazioni di calcolo, gestire set di dati di grandi dimensioni o addestrare modelli ML di grandi dimensioni. L'elenco seguente illustra le sfide più comuni che potresti affrontare quando esegui un processo di addestramento ML su larga scala. + Devi prendere decisioni su come distribuire il calcolo in base alle attività di machine learning, alle librerie software che desideri utilizzare e alle risorse di calcolo. + Non tutte le attività di machine learning sono semplici da distribuire. Inoltre, non tutte le librerie ML supportano il calcolo distribuito. + Il calcolo distribuito potrebbe non portare sempre a un aumento lineare dell'efficienza di calcolo. In particolare, è necessario identificare se i dati I/O e la comunicazione tra GPU presentano difficoltà o causano sovraccarichi. + Il calcolo distribuito potrebbe disturbare i processi numerici e modificare la precisione del modello. In particolare per quanto riguarda l'addestramento su reti neurali parallele ai dati, quando modifichi la dimensione globale del batch durante la scalabilità a un cluster di calcolo più grande, dovrai regolare anche il tasso di apprendimento di conseguenza. SageMaker L'intelligenza artificiale fornisce soluzioni di formazione distribuite per alleviare tali sfide in vari casi d'uso. Scegli una delle seguenti opzioni che meglio si adatta al tuo caso d'uso. **Topics** + [Opzione 1: utilizza un algoritmo integrato di SageMaker intelligenza artificiale che supporti l'allenamento distribuito](#distributed-training-options-1) + [Opzione 2: esegui un codice ML personalizzato nell'ambiente di formazione o elaborazione gestito dall'IA SageMaker](#distributed-training-options-2) + [Opzione 3: scrivere il proprio codice di addestramento distribuito personalizzato](#distributed-training-options-3) + [Opzione 4: avviare più processi in parallelo o in sequenza](#distributed-training-options-4) ## Opzione 1: utilizza un algoritmo integrato di SageMaker intelligenza artificiale che supporti l'allenamento distribuito SageMaker L'intelligenza artificiale fornisce [algoritmi integrati](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) che puoi utilizzare immediatamente tramite la console SageMaker AI o l'SDK SageMaker Python. Utilizzando gli algoritmi integrati, non dovrai dedicare tempo alla personalizzazione del codice, alla comprensione della scienza alla base dei modelli o all'esecuzione di Docker su istanze Amazon EC2 fornite. Un sottoinsieme degli algoritmi integrati nell' SageMaker intelligenza artificiale supporta l'addestramento distribuito. Per verificare se l'algoritmo di tua scelta supporta l'addestramento distribuito, consulta la colonna **Parallelizzabile** nella tabella [Informazioni comuni sugli algoritmi integrati](https://docs.aws.amazon.com/sagemaker/latest/dg/common-info-all-im-models.html). **Alcuni algoritmi supportano l'addestramento distribuito multiistanza, mentre il resto degli algoritmi parallelizzabili supporta la parallelizzazione su più istanze GPUs in una singola istanza, come indicato nella colonna Parallelizable.** ## Opzione 2: esegui un codice ML personalizzato nell'ambiente di formazione o elaborazione gestito dall'IA SageMaker SageMaker I lavori di intelligenza artificiale possono creare ambienti di formazione distribuiti per casi d'uso e framework specifici. Questo ambiente funge da ready-to-use lavagna, in cui è possibile importare ed eseguire il proprio codice ML. ### Se il tuo codice ML utilizza un framework di deep learning Puoi avviare lavori di formazione distribuiti utilizzando i [Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers) for SageMaker Training, che puoi orchestrare tramite i moduli Python dedicati nell'[SDK AI SageMaker Python](http://sagemaker.readthedocs.io/) o tramite,. SageMaker APIs [AWS CLI[AWS SDK per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html)](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/index.html) SageMaker [L'intelligenza artificiale fornisce contenitori di formazione per framework di apprendimento automatico [PyTorch[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/index.html)](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/index.html), tra cui [Hugging Face](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html) Transformers e Apache. MXNet](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/index.html) Sono disponibili due opzioni per scrivere codice di deep learning per l’addestramento distribuito. + ** SageMaker Le librerie di formazione distribuite dall'IA** Le librerie di formazione distribuite sull' SageMaker intelligenza AWS artificiale propongono codice gestito per il parallelismo dei dati delle reti neurali e il parallelismo dei modelli. SageMaker La formazione distribuita sull'intelligenza artificiale include anche client di avvio integrati nell'SDK SageMaker Python e non è necessario creare codice di avvio parallelo. Per saperne di più, consulta la libreria di parallelismo [dei dati di SageMaker AI e la libreria di parallelismo](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel.html) dei modelli di [SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel.html). + **Librerie di addestramento distribuito open source** I framework open source hanno i propri meccanismi di distribuzione come [DistributedDataParallelism (DDP](https://pytorch.org/docs/stable/notes/ddp.html)) in o moduli. PyTorch `tf.distribute` TensorFlow Puoi scegliere di eseguire questi framework di formazione distribuiti nei contenitori di framework gestiti dall'intelligenza artificiale. SageMaker [Ad esempio, il codice di esempio per l'[addestramento di MaskrCNN nell' SageMaker intelligenza artificiale](https://github.com/aws-samples/amazon-sagemaker-cv) mostra come utilizzare sia PyTorch DDP nel contenitore del PyTorch framework SageMaker AI che Horovod nel contenitore del framework.](https://horovod.readthedocs.io/en/stable/) SageMaker TensorFlow SageMaker [I contenitori AI ML sono inoltre dotati di [MPI](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/mpi_on_sagemaker/intro/mpi_demo.ipynb) preinstallato, quindi puoi parallelizzare lo script del punto di ingresso utilizzando mpi4py.](https://mpi4py.readthedocs.io/en/stable/) L'utilizzo dei contenitori di formazione integrati MPI è un'ottima opzione quando si avvia un programma di avvio di formazione distribuito di terze parti o si scrive codice parallelo ad hoc nell'ambiente di formazione gestito SageMaker dall'IA. *Note per l'addestramento sulla rete neurale parallela ai dati su GPUs* + **Se necessario, passa al parallelismo multi-GPU e multi-macchina** Spesso eseguiamo processi du addestramento sulle reti neurali su istanze con più CPU o più GPU. Ogni istanza basata su GPU di solito contiene più dispositivi GPU. Di conseguenza, l'elaborazione distribuita su GPU può avvenire all'interno di una singola istanza GPU con più istanze GPUs (addestramento multi-GPU a nodo singolo) o su più istanze GPU con più core GPU ciascuna (addestramento multi-GPU multinodo). La formazione su istanza singola consente di scrivere codice ed eseguire il debug in modo più semplice e la velocità effettiva tra i nodi è in genere più elevata rispetto alla velocità effettiva tra nodi. GPU-to-GPU GPU-to-GPU Pertanto, è consigliabile scalare innanzitutto il parallelismo dei dati verticalmente (utilizzare un'istanza GPU con più istanze) ed espanderlo a più istanze GPU, se necessario. GPUs Ciò potrebbe non applicarsi ai casi in cui il budget della CPU è elevato (ad esempio, un carico di lavoro enorme per la preelaborazione dei dati) e quando il CPU-to-GPU rapporto di un'istanza multi-GPU è troppo basso. In tutti i casi, è necessario sperimentare diverse combinazioni di tipi di istanze in base alle proprie esigenze di addestramento in machine learning e al proprio carico di lavoro. + **Monitoraggio della qualità della convergenza** Quando si addestra una rete neurale con parallelismo di dati, l'aumento del numero GPUs mantenendo costante la dimensione dei mini-batch per GPU comporta un aumento delle dimensioni del mini-batch globale per il processo MSGD (mini-batch stochastic gradient descent). È noto che le dimensioni dei mini-batch per MSGD influiscono sul rumore di discesa e sulla convergenza. Per ridimensionare correttamente preservando la precisione, è necessario regolare altri iperparametri come il tasso di apprendimento [[Goyal et al.](https://arxiv.org/abs/1706.02677) (2017)]. + **Monitora i colli di bottiglia I/O ** All'aumentare del numero di GPUs, dovrebbe aumentare anche la velocità effettiva di archiviazione in lettura e scrittura. Assicurati che l'origine dati e la pipeline non diventino ostacoli. + **Modifica dello script di addestramento in base alle esigenze** Gli script di addestramento scritti per l'addestramento a GPU singola devono essere modificati per l'addestramento multi-GPU a più nodi. Nella maggior parte delle librerie di parallelismo dei dati, è necessaria la modifica degli script per effettuare le seguenti operazioni. + Assegnare batch di dati di addestramento a ciascuna GPU. + Utilizzate un ottimizzatore in grado di gestire il calcolo del gradiente e l'aggiornamento dei parametri su più livelli. GPUs + Assegnare la responsabilità del checkpoint a un host e a una GPU specifici. ### Se il codice ML prevede l'elaborazione di dati tabulari PySpark è un frontend Python di Apache Spark, un framework di calcolo distribuito open source. PySpark è stato ampiamente adottato per l'elaborazione distribuita di dati tabulari per carichi di lavoro di produzione su larga scala. Se desideri eseguire codice di elaborazione dati tabulare, prendi in considerazione l'utilizzo dei [ PySpark contenitori SageMaker Processing](https://docs.aws.amazon.com/sagemaker/latest/dg/use-spark-processing-container.html) e l'esecuzione di processi paralleli. Puoi anche eseguire processi di elaborazione dati in parallelo utilizzando SageMaker Training and SageMaker Processing APIs in Amazon SageMaker Studio Classic, che è integrato con [Amazon EMR](https://aws.amazon.com/blogs/machine-learning/part-1-create-and-manage-amazon-emr-clusters-from-sagemaker-studio-to-run-interactive-spark-and-ml-workloads/) e. [AWS Glue](https://aws.amazon.com/about-aws/whats-new/2022/09/sagemaker-studio-supports-glue-interactive-sessions/?nc1=h_ls) ## Opzione 3: scrivere il proprio codice di addestramento distribuito personalizzato Quando invii un lavoro di formazione o elaborazione all' SageMaker IA, le API SageMaker Training and SageMaker AI Processing avviano istanze di calcolo Amazon EC2. Puoi personalizzare l'ambiente di formazione ed elaborazione nelle istanze eseguendo il tuo contenitore Docker o installando librerie aggiuntive nei contenitori gestiti. AWS Per ulteriori informazioni su Docker with SageMaker Training, consulta [Adattamento del proprio contenitore Docker per l'utilizzo con l' SageMaker intelligenza artificiale e Creazione di un contenitore con](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own.html) [algoritmi e modelli personalizzati](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-create.html). Per ulteriori informazioni su Docker with SageMaker AI Processing, consulta [Use](https://docs.aws.amazon.com/sagemaker/latest/dg/use-your-own-processing-code.html) Your Own Processing Code. Ogni ambiente di lavoro di SageMaker formazione contiene un file di configurazione in `/opt/ml/input/config/resourceconfig.json` e ogni ambiente di lavoro di SageMaker Processing contiene un file di configurazione simile in`/opt/ml/config/resourceconfig.json`. Il codice può leggere questo file per trovare `hostnames` e stabilire comunicazioni tra i nodi. Per ulteriori informazioni, incluso lo schema del file JSON, consulta [Distributed Training Configuration](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training) e [How Amazon SageMaker Processing Configures Your Processing Container](https://docs.aws.amazon.com/sagemaker/latest/dg/build-your-own-processing-container.html#byoc-config). Puoi anche installare e utilizzare librerie di calcolo distribuite di terze parti come [Ray](https://github.com/aws-samples/aws-samples-for-ray/tree/main/sagemaker) o DeepSpeed in SageMaker AI. È inoltre possibile utilizzare SageMaker Training and SageMaker Processing per eseguire calcoli distribuiti personalizzati che non richiedono la comunicazione tra lavoratori. Nella letteratura informatica, queste attività sono spesso descritte come di *facile parallelizzabilità* o di *zero condivisione*. Gli esempi includono l'elaborazione parallela di file di dati, l'addestramento di modelli in parallelo su diverse configurazioni o l'esecuzione di inferenze in batch su una raccolta di record. Puoi parallelizzare in modo semplice questi casi d'uso senza condivisione con Amazon AI. SageMaker Quando avvii un processo di SageMaker Training o SageMaker Processing su un cluster con più nodi, l' SageMaker IA per impostazione predefinita replica e avvia il codice di addestramento (in Python o Docker) su tutti i nodi. Le attività che richiedono la distribuzione casuale dei dati di input su più nodi possono essere facilitate `S3DataDistributionType=ShardedByS3Key` impostando la configurazione di immissione dei dati dell'API AI. SageMaker `TrainingInput` ## Opzione 4: avviare più processi in parallelo o in sequenza È inoltre possibile distribuire un flusso di lavoro di elaborazione ML in attività di elaborazione parallele o sequenziali più piccole, ciascuna rappresentata dal proprio processo di SageMaker formazione o SageMaker elaborazione. La suddivisione di un'attività in più processi può essere utile per le seguenti situazioni o attività: + Quando sono presenti [canali di dati](https://docs.aws.amazon.com/sagemaker/latest/dg/model-train-storage.html) e voci di metadati specifici (come iperparametri, configurazione del modello o tipi di istanza) per ogni attività secondaria. + Quando si implementano le fasi di ripetizione dei tentativi a livello di sottoattività. + Quando si modifica la configurazione delle sottoattività nel corso del carico di lavoro, ad esempio durante l’addestramento sull'aumento delle dimensioni dei batch. + Quando è necessario eseguire un'attività di machine learning che richiede più tempo del tempo di addestramento massimo consentito per un singolo processo di addestramento (massimo 28 giorni). + Quando diverse fasi di un flusso di lavoro di elaborazione richiedono tipi di istanze diversi. Per il caso specifico della ricerca iperparametrica, usa [SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning.html) Automated Model Tuning. SageMaker AI Automated Model Tuning è un orchestratore di ricerca parametrica senza server che avvia più lavori di formazione per tuo conto, secondo una logica di ricerca che può essere casuale, bayesiana o. HyperBand [Inoltre, per orchestrare più lavori di formazione, puoi prendere in considerazione anche strumenti di orchestrazione del flusso di lavoro, come Pipelines [SageMaker ,](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/index.html) Step [AWS Functions e Apache Airflow supportati](https://docs.aws.amazon.com/step-functions/latest/dg/connect-sagemaker.html) da [Amazon Managed Workflows for Apache Airflow (MWAA) e AI Workflows](https://aws.amazon.com/managed-workflows-for-apache-airflow/). SageMaker ](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/using_workflow.html)