Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Adaptación del script de entrenamiento para utilizar las operaciones colectivas de SMDDP
Los ejemplos de guiones de entrenamiento que se proporcionan en esta sección están simplificados y destacan solo los cambios necesarios para habilitar la biblioteca de paralelismo de datos distribuidos (SMDDP) de SageMaker IA en su guión de entrenamiento. Para ver ejemplos del cuaderno de end-to-end Jupyter que muestran cómo ejecutar un trabajo de formación distribuido con la biblioteca SMDDP, consulte. [Ejemplos de bibliotecas de paralelismo de datos de Amazon SageMaker AI](distributed-data-parallel-v2-examples.md)
**Topics**
+ [Utilice la biblioteca SMDDP en su guion de formación PyTorch](data-parallel-modify-sdp-pt.md)
+ [Utilice la biblioteca SMDDP en su PyTorch script de entrenamiento de Lightning](data-parallel-modify-sdp-pt-lightning.md)
+ [Utilice la biblioteca SMDDP en su script de TensorFlow entrenamiento (obsoleta)](data-parallel-modify-sdp-tf2.md)
# Utilice la biblioteca SMDDP en su guion de formación PyTorch
[A partir de la biblioteca de paralelismo de datos distribuidos (SMDDP) de SageMaker IA, versión 1.4.0, puede utilizarla como una opción de back-end para el paquete distribuido. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) Para usar el SMDDP `AllReduce` y las operaciones `AllGather` colectivas, solo necesita importar la biblioteca SMDDP al principio del script de entrenamiento y configurar SMDDP como el servidor de los módulos distribuidos durante la inicialización del grupo de procesos. PyTorch Con la especificación de backend de una sola línea, puede mantener intactos todos los módulos distribuidos nativos PyTorch y todo el guion de formación. [Los siguientes fragmentos de código muestran cómo utilizar la biblioteca SMDDP como backend de los paquetes de formación distribuidos PyTorch basados en [PyTorch datos: distributed data parallel (DDP), [PyTorch fully sharded data paralelism](https://pytorch.org/docs/stable/fsdp.html) (FSDP)](https://pytorch.org/docs/stable/notes/ddp.html) y Megatron-. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed)
## PyTorch Para DDP o FSDP
Inicialice el grupo de procesos de la siguiente manera.
```
import torch.distributed as dist
import smdistributed.dataparallel.torch.torch_smddp
dist.init_process_group(backend="smddp")
```
**nota**
(Solo para trabajos de PyTorch DDP) Actualmente, el `smddp` backend no admite la creación de grupos de subprocesos con la API. `torch.distributed.new_group()` No puede usar el backend `smddp` simultáneamente con otros backends de grupos de procesos, como `NCCL` y `Gloo`.
## Para DeepSpeed Megatron- DeepSpeed
Inicialice el grupo de procesos de la siguiente manera.
```
import deepspeed
import smdistributed.dataparallel.torch.torch_smddp
deepspeed.init_distributed(dist_backend="smddp")
```
**nota**
Para usar `AllGather` de SMDDP con los lanzadores basados en `mpirun` (`smdistributed` y `pytorchddp`) en [Lanzamiento de trabajos de formación distribuidos con SMDDP mediante el SDK de Python SageMaker](data-parallel-use-api.md), también debe establecer la siguiente variable de entorno en el script de entrenamiento.
```
export SMDATAPARALLEL_OPTIMIZE_SDP=true
```
Para obtener orientación general sobre cómo escribir un guion de entrenamiento del PyTorch FSDP, consulte Capacitación [avanzada de modelos con datos totalmente fragmentados en paralelo (FSDP](https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html)) en la documentación. PyTorch
Para obtener orientación general sobre cómo escribir un guion de formación sobre PyTorch DDP, consulte [Introducción a los datos distribuidos en paralelo](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) en la PyTorch documentación.
Cuando haya terminado de adaptar su script de entrenamiento, continúe con [Lanzamiento de trabajos de formación distribuidos con SMDDP mediante el SDK de Python SageMaker](data-parallel-use-api.md).
# Utilice la biblioteca SMDDP en su PyTorch script de entrenamiento de Lightning
Si desea utilizar su guion de entrenamiento de [PyTorchLightning](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction.html) y ejecutar un trabajo de formación en paralelo de datos distribuidos en SageMaker IA, puede ejecutar el trabajo de formación con cambios mínimos en su guion de formación. Los cambios necesarios incluyen los siguientes: importar los PyTorch módulos de la `smdistributed.dataparallel` biblioteca, configurar las variables de entorno para que PyTorch Lightning acepte las variables de entorno de SageMaker IA predefinidas en el kit de herramientas de SageMaker entrenamiento y activar la biblioteca SMDDP configurando el backend del grupo de procesos en. `"smddp"` Para obtener más información, siga las siguientes instrucciones que desglosan los pasos con ejemplos de código.
**nota**
La compatibilidad con PyTorch Lightning está disponible en la biblioteca paralela de datos de SageMaker IA v1.5.0 y versiones posteriores.
## PyTorch Lightning == v2.1.0 y == 2.0.1 PyTorch
1. Importe la biblioteca `pytorch_lightning` y los módulos `smdistributed.dataparallel.torch`.
```
import lightning as pl
import smdistributed.dataparallel.torch.torch_smddp
```
1. Instancie el. [LightningEnvironment](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.plugins.environments.LightningEnvironment.html)
```
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. **Para el PyTorch DDP**[: crea un objeto de la [DDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.DDPStrategy.html)clase con el para y el `"smddp"``"gpu"` para`accelerator`, `process_group_backend` y pásalo a la clase 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
)
```
**Para el PyTorch FSDP**[: crea un objeto de la [FSDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.FSDPStrategy.html)clase (con la [política de empaquetado](https://pytorch.org/docs/stable/fsdp.html) que prefieras) con un para y un `"smddp"``"gpu"` para `process_group_backend` y `accelerator` pásalo a la clase de entrenador.](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
)
```
Cuando haya terminado de adaptar su script de entrenamiento, continúe con [Lanzamiento de trabajos de formación distribuidos con SMDDP mediante el SDK de Python SageMaker](data-parallel-use-api.md).
**nota**
Cuando crees un PyTorch estimador de SageMaker IA y envíes una solicitud de trabajo de formación[Lanzamiento de trabajos de formación distribuidos con SMDDP mediante el SDK de Python SageMaker](data-parallel-use-api.md), tendrás que proporcionar la instalación `pytorch-lightning` y el `requirements.txt` SageMaker contenedor de formación `lightning-bolts` en IA. PyTorch
```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Para obtener más información sobre cómo especificar el directorio de origen para colocar el `requirements.txt` archivo junto con el guion de entrenamiento y el envío de un trabajo, consulte [Uso de bibliotecas de terceros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) en la *documentación del SDK de Python de Amazon SageMaker AI*.
# Utilice la biblioteca SMDDP en su script de TensorFlow entrenamiento (obsoleta)
**importante**
La biblioteca SMDDP dejó de ofrecer soporte para la versión TensorFlow 2.11.0 y ya no estará disponible a partir DLCs de TensorFlow esa fecha. Para encontrar versiones anteriores TensorFlow DLCs con la biblioteca SMDDP instalada, consulte. [Marcos admitidos](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks)
Los siguientes pasos le muestran cómo modificar un script de TensorFlow entrenamiento para utilizar la biblioteca paralela de datos distribuidos de SageMaker AI.
La biblioteca APIs está diseñada para ser similar a Horovod APIs. Para obtener información adicional sobre cada API que ofrece la biblioteca TensorFlow, consulta la [documentación de la TensorFlow API paralela de datos distribuidos de SageMaker IA](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation).
**nota**
SageMaker AI distributed data parallel se adapta a guiones de TensorFlow entrenamiento compuestos por módulos `tf` principales, excepto `tf.keras` módulos. SageMaker Los datos distribuidos paralelos de IA no son compatibles TensorFlow con la implementación de Keras.
**nota**
La biblioteca de paralelismo de datos distribuidos mediante SageMaker IA es compatible con la precisión mixta automática (AMP) desde el primer momento. No se necesita ninguna acción adicional para habilitar AMP que no sean las modificaciones a nivel de marco de su script de entrenamiento. Si los gradientes están activados FP16, la biblioteca de paralelismo de datos de SageMaker IA ejecuta su operación en ella. `AllReduce` FP16 Para obtener más información sobre cómo implementar AMP APIs en tu guion de entrenamiento, consulta los siguientes recursos:
[Marcos: TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) en la *documentación de rendimiento del aprendizaje profundo de NVIDIA*
[Precisión mixta automática para aprendizaje profundo](https://developer.nvidia.com/automatic-mixed-precision) en los *Documentos para desarrolladores de NVIDIA*
[TensorFlow precisión mixta APIs](https://www.tensorflow.org/guide/mixed_precision) en la *TensorFlowdocumentación*
1. Importa el TensorFlow cliente de la biblioteca e inicialízalo.
```
import smdistributed.dataparallel.tensorflow as sdp
sdp.init()
```
1. Fijar cada GPU a un único proceso de `smdistributed.dataparallel` con `local_rank`: esto se refiere a la clasificación relativa del proceso dentro de un nodo determinado. La API `sdp.tensorflow.local_rank()` proporciona la clasificación local del dispositivo. El nodo principal es el rango 0 y los nodos de trabajo son de rango 1, 2, 3, etc. Esto se invoca en el siguiente bloque de código como`sdp.local_rank()`. `set_memory_growth`no está directamente relacionado con la SageMaker IA distribuida, pero debe configurarse para el entrenamiento distribuido con ella 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. Escale la tasa de aprendizaje según el número de trabajadores. La API `sdp.tensorflow.size()` le proporciona el número de trabajadores del clúster. Esto se invoca en el siguiente código como `sdp.size()`.
```
learning_rate = learning_rate * sdp.size()
```
1. Utilice el `DistributedGradientTape` de la biblioteca para optimizar las operaciones `AllReduce`durante el entrenamiento. Esto envuelve `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. Transmite las variables de modelo iniciales desde el nodo principal (rango 0) a todos los nodos de trabajo (rangos 1 a n). Esto es necesario para garantizar una inicialización coherente en todos los rangos de trabajo. Utilice la API `sdp.tensorflow.broadcast_variables` después de inicializar el modelo y las variables del optimizador. Esto se invoca en el siguiente bloque de código como `sdp.broadcast_variables()`.
```
sdp.broadcast_variables(model.variables, root_rank=0)
sdp.broadcast_variables(opt.variables(), root_rank=0)
```
1. Por último, modifique su script para guardar los puntos de control solo en el nodo principal. El nodo principal tiene un modelo sincronizado. Esto también evita que los nodos de trabajo sobrescriban los puntos de control y, posiblemente, corrompa los puntos de control.
```
if sdp.rank() == 0:
checkpoint.save(checkpoint_dir)
```
El siguiente es un ejemplo de guion de TensorFlow entrenamiento para un entrenamiento distribuido con la biblioteca.
```
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)
```
Cuando haya terminado de adaptar su script de entrenamiento, pase a [Lanzamiento de trabajos de formación distribuidos con SMDDP mediante el SDK de Python SageMaker](data-parallel-use-api.md).