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