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