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.
# (Archivado) Biblioteca de paralelismo de modelos de SageMaker v1.x
**importante**
El 19 de diciembre de 2023, se lanzó la biblioteca de paralelismo de modelos de SageMaker (SMP) v2. Las capacidades de SMP v1 no se admiten en futuras versiones, en favor de la biblioteca de SMP v2. La sección y los temas siguientes están archivados y son específicos del uso de la biblioteca de SMP v1. Para obtener información acerca del uso de la biblioteca de SMP v2, consulte [Biblioteca de paralelismo de modelos de SageMaker v2](model-parallel-v2.md).
Utilice la biblioteca de paralelismo de modelos de Amazon SageMaker AI para entrenar modelos de aprendizaje profundo (DL) de gran tamaño que son difíciles de entrenar debido a las limitaciones de memoria de la GPU. La biblioteca divide un modelo de forma automática y eficiente en varias GPU e instancias. Con la biblioteca, puede lograr una precisión de predicción objetivo más rápido mediante el entrenamiento eficiente de modelos DL más grandes con miles de millones o billones de parámetros.
Puede utilizar la biblioteca para dividir automáticamente sus propios modelos TensorFlow y PyTorch en varias GPU y varios nodos con cambios de código mínimos. Puede acceder a la API de la biblioteca a través del SageMaker Python SDK.
Utilice las siguientes secciones para obtener más información sobre el paralelismo de modelos y la biblioteca de paralelismo de modelos de SageMaker. La documentación de la API de esta biblioteca se encuentra en las [API de entrenamiento distribuido](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) de la *documentación del SageMaker Python SDK v2.199.0*.
**Topics**
+ [Introducción al paralelismo de modelos](model-parallel-intro.md)
+ [Marcos compatibles y Regiones de AWS](distributed-model-parallel-support.md)
+ [Características principales de la biblioteca de paralelismo de SageMaker modelos](model-parallel-core-features.md)
+ [Ejecute un trabajo de formación SageMaker distribuido con Model Paralelism](model-parallel-use-api.md)
+ [Puntos de control y ajuste de un modelo con paralelismo de modelos](distributed-model-parallel-checkpointing-and-finetuning.md)
+ [Ejemplos de la biblioteca de paralelismo de modelos Amazon SageMaker AI v1](distributed-model-parallel-examples.md)
+ [SageMaker Mejores prácticas de paralelismo de modelos distribuidos](model-parallel-best-practices.md)
+ [Consejos y dificultades de configuración de la biblioteca de paralelismo de modelos SageMaker distribuidos](model-parallel-customize-tips-pitfalls.md)
+ [Solución de problemas de paralelismo de modelos](distributed-troubleshooting-model-parallel.md)
# Introducción al paralelismo de modelos
El paralelismo de modelos es un método de entrenamiento distribuido en el que el modelo de aprendizaje profundo se divide en varios dispositivos, dentro de las instancias o entre ellas. Esta página de introducción proporciona una descripción general de alto nivel sobre el paralelismo de modelos, una descripción de cómo puede ayudar a superar los problemas que surgen al entrenar modelos DL que suelen ser de un tamaño muy grande y ejemplos de lo que ofrece la biblioteca de modelos SageMaker paralelos para ayudar a gestionar las estrategias de modelos paralelos, así como el consumo de memoria.
## ¿Qué es el paralelismo de modelos?
Al aumentar el tamaño de los modelos de aprendizaje profundo (capas y parámetros), se obtiene mayor precisión en tareas complejas, como la visión artificial y el procesamiento del lenguaje natural. Sin embargo, existe un límite en el tamaño máximo de modelo que puede caber en una sola GPU. Al entrenar modelos de DL, las limitaciones de memoria de la GPU pueden ser cuellos de botella de las siguientes maneras:
+ Limitan el tamaño del modelo que se puede entrenar, ya que el consumo de memoria de un modelo se amplía proporcionalmente al número de parámetros.
+ Limitan el tamaño del lote por GPU durante el entrenamiento, lo que reduce el uso de la GPU y la eficiencia del entrenamiento.
Para superar las limitaciones asociadas con el entrenamiento de un modelo en una sola GPU, SageMaker proporciona la biblioteca de modelos parallel para ayudar a distribuir y entrenar los modelos DL de manera eficiente en varios nodos de procesamiento. Además, con la biblioteca, puede lograr un entrenamiento distribuido más optimizado utilizando dispositivos compatibles con EFA, que mejoran el rendimiento de la comunicación entre nodos con baja latencia, alto rendimiento y omisión del sistema operativo.
## Calcule los requisitos de memoria antes de utilizar el paralelismo de modelos
Antes de utilizar la biblioteca de SageMaker modelos parallel, tenga en cuenta lo siguiente para hacerse una idea de los requisitos de memoria necesarios para el entrenamiento de modelos DL de gran tamaño.
Para un trabajo de entrenamiento que utilice los optimizadores AMP (FP16) y Adam, la memoria de GPU requerida por parámetro es de unos 20 bytes, que podemos desglosar de la siguiente manera:
+ Un FP16 parámetro: \$1 2 bytes
+ Un FP16 gradiente de \$1 2 bytes
+ Un estado del FP32 optimizador de \$1 8 bytes basado en los optimizadores Adam
+ Una FP32 copia del parámetro de \$1 4 bytes (necesaria para la operación `optimizer apply` (OA))
+ Una FP32 copia del gradiente de aproximadamente 4 bytes (necesaria para la operación OA)
Incluso para un modelo DL relativamente pequeño con 10 000 millones de parámetros, puede requerir al menos 200 GB de memoria, que es mucho más grande que la memoria típica de una GPU (por ejemplo, la NVIDIA A100 con 40 GB/80 GB de memoria y la V100 con 16/32 GB) disponible en una sola GPU. Tenga en cuenta que, además de los requisitos de memoria para los estados del modelo y del optimizador, hay otros consumidores de memoria, como las activaciones que se generan en la transferencia directa. La memoria requerida puede superar con creces los 200 GB.
Para la formación distribuida, le recomendamos que utilice instancias P3 y P4 de Amazon EC2 que tengan NVIDIA V100 y A100 Tensor Core, respectivamente. GPUs Para obtener más información sobre especificaciones como los núcleos de la CPU, la RAM, el volumen de almacenamiento adjunto y el ancho de banda de la red, consulte la sección *Computación acelerada* de la página [Tipos de instancias de Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
Incluso con las instancias de computación acelerada, es evidente que los modelos con unos 10 000 millones de parámetros, como Megatron-LM y la T5, e incluso modelos más grandes con cientos de miles de millones de parámetros, como el GPT-3, no caben réplicas de modelos en cada dispositivo con GPU.
## Cómo emplea la biblioteca el paralelismo de modelos y las técnicas de ahorro de memoria
La biblioteca consta de varios tipos de funciones de paralelismo de modelos y funciones de ahorro de memoria, como la fragmentación del estado del optimizador, los puntos de control de activación y la descarga de la activación. Todas estas técnicas se pueden combinar para entrenar de manera eficiente modelos grandes que constan de cientos de miles de millones de parámetros.
**Topics**
+ [Paralelismo de datos fragmentados (disponible para) PyTorch](#model-parallel-intro-sdp)
+ [PyTorch TensorFlowParalelismo de canalización (disponible para y)](#model-parallel-intro-pp)
+ [Paralelismo tensorial (disponible para) PyTorch](#model-parallel-intro-tp)
+ [Optimizador PyTorch de fragmentación de estados (disponible para)](#model-parallel-intro-oss)
+ [Activación, descarga y puntos de control (disponibles para) PyTorch](#model-parallel-intro-activation-offloading-checkpointing)
+ [Elegir las técnicas adecuadas para su modelo](#model-parallel-intro-choosing-techniques)
### Paralelismo de datos fragmentados (disponible para) PyTorch
El *paralelismo de datos fragmentados* es una técnica de entrenamiento distribuido que ahorra memoria y que divide el estado de un modelo (parámetros del modelo, gradientes y estados del optimizador) dentro de un grupo de datos paralelos. GPUs
SageMaker **[La IA implementa el paralelismo de datos fragmentados mediante la implementación de **MIC**, que es una biblioteca que minimiza la comunicación a escala y que se analiza en la entrada del blog Near-linear **Scaling** of Gigantic-model training on. AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws)**
Puede aplicar el paralelismo de datos partidos a su modelo como estrategia independiente. Además, si utilizas las instancias de GPU de mayor rendimiento equipadas con NVIDIA A100 Tensor Core GPUs, podrás aprovechar la mayor velocidad de entrenamiento que ofrece SMDDP `ml.p4d.24xlarge` Collectives. `AllGather`
Para profundizar en el paralelismo de datos fragmentados y aprender a configurarlo o utilizar una combinación del paralelismo de datos fragmentados con otras técnicas, como el paralelismo tensorial y el entrenamiento, consulte. FP16 [Paralelismo de datos partidos](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
### PyTorch TensorFlowParalelismo de canalización (disponible para y)
El *paralelismo de canalización* divide el conjunto de capas u operaciones en el conjunto de dispositivos, dejando intacta cada operación. Al especificar un valor para el número de particiones del modelo (`pipeline_parallel_degree`), el número total de GPUs (`processes_per_host`) debe ser divisible por el número de particiones del modelo. Para configurarlo correctamente, debe especificar los valores correctos de los parámetros `pipeline_parallel_degree` y `processes_per_host`. La matemática simple es la siguiente:
```
(pipeline_parallel_degree) x (data_parallel_degree) = processes_per_host
```
La biblioteca se encarga de calcular el número de réplicas del modelo (también denominadas `data_parallel_degree`) teniendo en cuenta los dos parámetros de entrada que usted proporciona.
Por ejemplo, si configuras `"pipeline_parallel_degree": 2` y `"processes_per_host": 8` utilizas una instancia de aprendizaje automático con ocho procesadores de GPU`ml.p3.16xlarge`, la biblioteca configura automáticamente el modelo distribuido en el paralelismo de datos GPUs y en cuatro direcciones. En la siguiente imagen, se muestra cómo se distribuye un modelo entre los ocho modelos, GPUs consiguiendo un paralelismo de datos de cuatro vías y un paralelismo de canalización de dos vías. Cada réplica del modelo, donde la definimos como un *grupo paralelo de tuberías* y la etiquetamos como`PP_GROUP`, está dividida en dos GPUs. Cada partición del modelo se asigna a cuatro GPUs, donde las cuatro réplicas de particiones están en un *grupo paralelo de datos* y se etiquetan como`DP_GROUP`. Sin paralelismo de tensores, el grupo de paralelismo de canalizaciones es esencialmente el grupo de paralelismo de modelos.
![\[Cómo se distribuye un modelo entre las ocho, GPUs logrando un paralelismo de datos de cuatro vías y un paralelismo de canalización bidireccional.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-pipeline-parallel-only.png)
Para profundizar en el paralelismo de las canalizaciones, consulte [Características principales de la biblioteca de paralelismo de SageMaker modelos](model-parallel-core-features.md).
Para empezar a ejecutar el modelo mediante el paralelismo de canalización, consulte [Ejecutar un trabajo de SageMaker entrenamiento distribuido con la biblioteca paralela de SageMaker modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html).
### Paralelismo tensorial (disponible para) PyTorch
El *paralelismo de tensores* divide capas individuales o`nn.Modules`, entre dispositivos, para que se ejecuten en paralelo. La siguiente figura muestra el ejemplo más simple de cómo la biblioteca divide un modelo con cuatro capas para lograr un paralelismo de tensores bidireccional (`"tensor_parallel_degree": 2`). Las capas de cada réplica del modelo se dividen en dos y se distribuyen en dos. GPUs En este caso de ejemplo, la configuración paralela del modelo también incluye `"pipeline_parallel_degree": 1` y `"ddp": True` (usa el PyTorch DistributedDataParallel paquete en segundo plano), por lo que el grado de paralelismo de los datos pasa a ser ocho. La biblioteca gestiona la comunicación entre las réplicas del modelo distribuido por tensores.
![\[El ejemplo más simple de cómo la biblioteca divide un modelo con cuatro capas para lograr un paralelismo de tensores bidireccional ("tensor_parallel_degree": 2).\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-tensor-parallel-only.png)
La utilidad de esta función reside en el hecho de que puede seleccionar capas específicas o un subconjunto de capas para aplicar el paralelismo de tensores. Para profundizar en el paralelismo tensorial y otras funciones que ahorran memoria y aprender a configurar una combinación de paralelismo tensorial y de canalización PyTorch, consulte. [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md)
### Optimizador PyTorch de fragmentación de estados (disponible para)
Para entender cómo la biblioteca realiza la *partición del estado del optimizador*, considere un modelo de ejemplo simple con cuatro capas. La idea clave para optimizar la fragmentación de estados es que no es necesario replicar el estado del optimizador en todos los estados. GPUs En cambio, una única réplica del estado del optimizador se divide en rangos de datos paralelos, sin redundancia entre los dispositivos. Por ejemplo, la GPU 0 mantiene el estado del optimizador para la capa uno, la siguiente GPU 1 mantiene el estado del optimizador para la capa 2, y así sucesivamente. La siguiente figura animada muestra una propagación hacia atrás con la técnica de partición del estado del optimizador. Al final de la propagación hacia atrás, hay tiempo de cálculo y de red para que la operación `optimizer apply` (OA) actualice los estados del optimizador y la operación `all-gather` (AG) para actualizar los parámetros del modelo para la siguiente iteración. Y lo que es más importante, la operación `reduce` puede superponerse con el procesamiento de la GPU 0, lo que resulta en una mayor eficiencia de la memoria y una propagación hacia atrás más rápida. En la implementación actual, las operaciones de AG y OA no se superponen con `compute`. Esto puede provocar un cálculo prolongado durante la operación de AG, por lo que podría haber una compensación.
![\[Una propagación hacia atrás con la técnica de partición de estado del optimizador.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-optimizer-state-sharding.gif)
Para obtener más información acerca de cómo utilizar esta función, consulte [Partición del estado del optimizador](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-optimizer-state-sharding.html).
### Activación, descarga y puntos de control (disponibles para) PyTorch
Para ahorrar memoria en la GPU, la biblioteca admite puntos de control de activación para evitar almacenar las activaciones internas en la memoria de la GPU para los módulos especificados por el usuario durante la transferencia. La biblioteca vuelve a calcular estas activaciones durante la pasada hacia atrás. Además, la función de descarga de activaciones transfiere las activaciones almacenadas a la memoria de la CPU y las recupera en la GPU durante la transferencia hacia atrás para reducir aún más el consumo de memoria de activación. Para obtener más información sobre cómo utilizar estas características, consulte [Puntos de control de activación](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-checkpointing.html) y [Descarga de activación](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-offloading.html).
### Elegir las técnicas adecuadas para su modelo
Para obtener más información sobre cómo elegir las técnicas y configuraciones correctas, consulte las [prácticas recomendadas de SageMaker Distributed Model Parallel](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-best-practices.html) y los [consejos y dificultades de configuración](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-customize-tips-pitfalls.html).
# Marcos compatibles y Regiones de AWS
Antes de usar la biblioteca de paralelismo de SageMaker modelos, comprueba los marcos y tipos de instancias compatibles y determina si hay suficientes cuotas en tu cuenta y. AWS Región de AWS
**nota**
Para consultar las últimas actualizaciones y notas de la versión de la biblioteca, consulta las [notas de la versión de SageMaker Model Parallel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) en la *documentación del SDK de SageMaker Python*.
## Marcos admitidos
La biblioteca de SageMaker modelos de paralelismo es compatible con los siguientes marcos de aprendizaje profundo y está disponible en AWS Deep Learning Containers (DLC) o se puede descargar como un archivo binario.
PyTorch versiones compatibles con SageMaker AI y la biblioteca de modelos de paralelismo SageMaker
| PyTorch versión | SageMaker versión de la biblioteca de paralelismo de modelos | URI de imagen DLC integrada `smdistributed-modelparallel` | URL del archivo binario\$1\$1 |
| --- | --- | --- | --- |
| v2.0.0 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-2.0.0/build-artifacts/2023-04-14-20-14/smdistributed\$1modelparallel-1.15.0-cp310-cp310-linux\$1x86\$164.whl |
| Versión 1.13.1 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.13.1/build-artifacts/2023-04-17-15-49/smdistributed\$1modelparallel-1.15.0-cp39-cp39-linux\$1x86\$164.whl |
| v1.12.1 | smdistributed-modelparallel==v1.13.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.1/build-artifacts/2022-12-08-21-34/smdistributed\$1modelparallel-1.13.0-cp38-cp38-linux\$1x86\$164.whl |
| Versión 1.12.0 | smdistributed-modelparallel==v1.11.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.0/build-artifacts/2022-08-12-16-58/smdistributed\$1modelparallel-1.11.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.11.0 | smdistributed-modelparallel==v1.10.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.11.0/build-artifacts/2022-07-11-19-23/smdistributed\$1modelparallel-1.10.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.10.2 | smdistributed-modelparallel==v1.7.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.2-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.10.0 | smdistributed-modelparallel==v1.5.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.9.1 | smdistributed-modelparallel==v1.4.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.9.1-gpu-py38-cu111-ubuntu20.04` | - |
| v1.8.1\$1 | smdistributed-modelparallel==v1.6.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.8.1-gpu-py36-cu111-ubuntu18.04` | - |
**nota**
La biblioteca de paralelismo de modelos v1.6.0 y versiones posteriores proporciona funciones ampliadas para. SageMaker PyTorch Para obtener más información, consulte [Características principales de la biblioteca de paralelismo de SageMaker modelos](model-parallel-core-features.md).
\$1\$1 Los URLs archivos binarios sirven para instalar la biblioteca de paralelismo de SageMaker modelos en contenedores personalizados. Para obtener más información, consulte [Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container).
TensorFlow versiones compatibles con SageMaker AI y la biblioteca de modelos de SageMaker paralelismo
| TensorFlow versión | SageMaker versión de la biblioteca de paralelismo de modelos | URI de imagen DLC integrada `smdistributed-modelparallel` |
| --- | --- | --- |
| v2.6.0 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.6.0-gpu-py38-cu112-ubuntu20.04 |
| v2.5.1 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.5.1-gpu-py37-cu112-ubuntu18.04 |
**Versiones de Hugging Face Transformers SageMaker compatibles con AI y SageMaker la biblioteca paralela de datos distribuidos**
Los AWS Deep Learning Containers de Hugging Face utilizan SageMaker los contenedores PyTorch de TensorFlow formación como imágenes base. Para buscar las versiones y versiones PyTorch combinadas de la biblioteca Hugging Face Transformers, consulta las versiones más recientes de [Hugging Face Containers TensorFlow y las versiones anteriores de Hugging](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) [Face Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#prior-hugging-face-container-versions).
## Regiones de AWS
La biblioteca paralela de SageMaker datos está disponible en todos los Regiones de AWS lugares [para los que SageMaker están en servicio los AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only). Para obtener más información, consulte [Imágenes de contenedores de aprendizaje profundo disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#available-deep-learning-containers-images).
## Tipos de instancias admitidos
La biblioteca de paralelismo de SageMaker modelos requiere uno de los siguientes tipos de instancias de ML.
| Tipo de instancia |
| --- |
| ml.g4dn.12xlarge |
| ml.p3.16xlarge |
| ml.p3dn.24xlarge |
| ml.p4d.24xlarge |
| ml.p4de.24xlarge |
Para ver las especificaciones de los tipos de instancias, consulte la sección **Computación acelerada** en la [página de tipos de instancias de Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Para obtener información sobre los precios de las instancias, consulta [Amazon SageMaker AI Pricing](https://aws.amazon.com/sagemaker/pricing/).
Si encuentra un mensaje de error similar al siguiente, siga las instrucciones que se indican en [Solicitar un aumento de la cuota de servicio para los recursos de SageMaker IA](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.
```
# Características principales de la biblioteca de paralelismo de SageMaker modelos
La biblioteca de paralelismo de modelos de Amazon SageMaker AI ofrece estrategias de distribución y técnicas de ahorro de memoria, como el paralelismo de datos fragmentados, el paralelismo tensorial, la partición de modelos por capas para la programación de canalizaciones y los puntos de control. Las estrategias y técnicas de paralelismo de modelos ayudan a distribuir modelos grandes en varios dispositivos, a la vez que optimizan la velocidad de entrenamiento y el consumo de memoria. La biblioteca también proporciona funciones auxiliares de Python, administradores de contexto y funciones contenedoras para adaptar su script de entrenamiento a la división automática o manual de su modelo.
Cuando implementa el paralelismo de modelos en su trabajo de entrenamiento, mantiene el mismo flujo de trabajo de dos pasos que se muestra en la sección [Ejecute un trabajo de SageMaker entrenamiento distribuido con](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html) paralelismo de modelos. Para adaptar el script de su entrenamiento, debe agregar cero o pocas líneas de código adicionales a su script de entrenamiento. Para iniciar un trabajo de entrenamiento con el script de entrenamiento adaptado, debe configurar los parámetros de configuración de la distribución para activar las funciones de ahorro de memoria o transferir valores según el grado de paralelismo.
Para empezar con los ejemplos, consulte los siguientes cuadernos de Jupyter, que muestran cómo utilizar la biblioteca de paralelismo de modelos. SageMaker
+ [PyTorch ejemplos de cuadernos](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel)
+ [TensorFlow cuadernos de ejemplo](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/tensorflow/model_parallel/mnist)
Para profundizar en las características principales de la biblioteca, consulte los siguientes temas.
**nota**
Las bibliotecas de formación SageMaker distribuidas están disponibles a través de los contenedores de PyTorch aprendizaje AWS profundo de Hugging Face TensorFlow y en SageMaker la plataforma de formación. Para utilizar las funciones de las bibliotecas de formación distribuidas, le recomendamos que utilice el SDK de SageMaker Python. También puedes configurarla manualmente en la sintaxis de solicitud JSON si utilizas SageMaker APIs SDK for Python (Boto3) o. AWS Command Line Interface En toda la documentación, las instrucciones y los ejemplos se centran en cómo utilizar las bibliotecas de formación distribuidas con el SDK de SageMaker Python.
**importante**
La biblioteca de SageMaker modelos de paralelismo es compatible con todas las funciones principales y admite el paralelismo de canalización para PyTorch. TensorFlow
**Topics**
+ [Paralelismo de datos partidos](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
+ [Canalización de un modelo](model-parallel-core-features-pipieline-parallelism.md)
+ [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md)
+ [Partición del estado del optimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md)
+ [Puntos de control de activación](model-parallel-extended-features-pytorch-activation-checkpointing.md)
+ [Descarga de activación](model-parallel-extended-features-pytorch-activation-offloading.md)
+ [FP16 Entrenamiento con paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md)
+ [Support para FlashAttention](model-parallel-attention-head-size-for-flash-attention.md)
# Paralelismo de datos partidos
El *paralelismo de datos fragmentados* es una técnica de entrenamiento distribuido que ahorra memoria y que divide el estado de un modelo (parámetros del modelo, gradientes y estados del optimizador) en un grupo paralelo de datos. GPUs
**nota**
El paralelismo de datos fragmentados está disponible en la biblioteca de paralelismo de modelos, versión 1.11.0 y versiones posteriores. PyTorch SageMaker
Al ampliar tu trabajo de entrenamiento a un clúster de GPU de gran tamaño, puedes reducir el consumo de memoria del modelo por GPU dividiendo el estado de entrenamiento del modelo en varias unidades. GPUs Esto ofrece dos ventajas: puede instalar modelos más grandes, que de otro modo se quedarían sin memoria con el paralelismo de datos estándar, o puede aumentar el tamaño del lote utilizando la memoria de la GPU liberada.
La técnica de paralelismo de datos estándar replica los estados de entrenamiento en el grupo paralelo de datos y realiza GPUs la agregación de gradientes en función de la operación. `AllReduce` El paralelismo de datos partidos modifica el procedimiento de entrenamiento distribuido de datos paralelos estándar para tener en cuenta la naturaleza partida de los estados del optimizador. Un grupo de rangos en los que se parten los estados del modelo y del optimizador se denomina *grupo de partición*. *La técnica de paralelismo de datos fragmentados divide los parámetros entrenables de un modelo y los gradientes y estados del optimizador correspondientes en el grupo de fragmentación. GPUs *
SageMaker [La IA logra un paralelismo de datos fragmentados mediante la implementación de indicadores de ingresos medios, algo que se analiza en la entrada del blog Near-linear scaling of gigantic-model training on. AWSAWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) En esta implementación, puede establecer el grado de partición como un parámetro configurable, que debe ser inferior al grado de paralelismo de los datos. Durante cada pasada hacia adelante y hacia atrás, MiC recombina temporalmente los parámetros del modelo durante toda la operación. GPUs `AllGather` Tras pasar cada capa hacia adelante o hacia atrás, MiCS vuelve a partir los parámetros para ahorrar memoria en la GPU. Durante el paso hacia atrás, el MIC reduce los gradientes y, al mismo tiempo, los fragmenta a lo largo GPUs de la operación. `ReduceScatter` Por último, MiCS aplica los gradientes locales reducidos y partidos a sus correspondientes particiones de parámetros locales, utilizando las particiones locales de los estados del optimizador. Para reducir la sobrecarga de comunicación, la biblioteca de paralelismo de SageMaker modelos busca previamente las siguientes capas en la fase de avance o retroceso y superpone la comunicación de red con el cálculo.
El estado de entrenamiento del modelo se replica en todos los grupos de partición. Esto significa que antes de aplicar los gradientes a los parámetros, la operación `AllReduce` debe realizarse en todos los grupos de partición, además de la operación `ReduceScatter` que se lleva a cabo dentro del grupo de partición.
En efecto, el paralelismo de datos partidos supone un equilibrio entre la sobrecarga de comunicación y la eficiencia de la memoria de la GPU. El uso del paralelismo de datos partidos aumenta el costo de la comunicación, pero el espacio de memoria por GPU (excluido el uso de memoria debido a las activaciones) se divide por el grado de paralelismo de los datos partidos, por lo que pueden caber modelos más grandes en el clúster de la GPU.
**Seleccionar el grado de paralelismo de los datos partidos**
Al seleccionar un valor para el grado de paralelismo de los datos partidos, el valor debe dividir uniformemente el grado de paralelismo de los datos. Por ejemplo, para un trabajo de paralelismo de datos de 8 vías, seleccione 2, 4 u 8 como grado de paralelismo de datos partidos. Al elegir el grado de paralelismo de los datos partidos, le recomendamos que comience con un número pequeño y vaya aumentado poco a poco hasta que el modelo quepa en la memoria y tenga el tamaño de lote deseado.
**Seleccionar el tamaño del lote**
Tras configurar el paralelismo de datos partidos, asegúrese de encontrar la configuración de entrenamiento más óptima que pueda ejecutarse correctamente en el clúster de la GPU. Para entrenar modelos de lenguaje grandes (LLM), comience con el tamaño de lote 1 y auméntelo gradualmente hasta llegar al punto en el que aparezca el error (OOM). out-of-memory Si encuentra el error OOM incluso con el tamaño de lote más pequeño, aplique un mayor grado de paralelismo de datos partidos o una combinación de paralelismo de datos partidos y paralelismo de tensores.
**Topics**
+ [Cómo aplicar el paralelismo de datos partidos a su trabajo de entrenamiento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
+ [Configuraciones de referencia](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use-config-sample)
+ [Paralelismo de datos partidos con colectivos SMDDP](#model-parallel-extended-features-pytorch-sharded-data-parallelism-smddp-collectives)
+ [Entrenamiento de precisión mixto con paralelismo de datos partidos](#model-parallel-extended-features-pytorch-sharded-data-parallelism-16bits-training)
+ [Paralelismo de datos partidos con paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism)
+ [Consejos y consideraciones a tener en cuenta para utilizar el paralelismo de datos partidos](#model-parallel-extended-features-pytorch-sharded-data-parallelism-considerations)
## Cómo aplicar el paralelismo de datos partidos a su trabajo de entrenamiento
Para empezar con el paralelismo de datos fragmentados, aplique las modificaciones necesarias al guion de entrenamiento y configure el estimador con los parámetros. SageMaker PyTorch sharded-data-parallelism-specific Considere también tomar valores de referencia y cuadernos de ejemplo como punto de partida.
### Adapta tu guion de entrenamiento PyTorch
Siga las instrucciones del [paso 1: modifique un guion de PyTorch entrenamiento](model-parallel-customize-training-script-pt.md) para envolver los objetos del modelo y del optimizador con los `smdistributed.modelparallel.torch` envoltorios de los módulos `torch.nn.parallel` y`torch.distributed`.
**(Opcional) Modificación adicional para registrar los parámetros externos del modelo**
Si el modelo está creado con `torch.nn.Module` y usa parámetros que no están definidos en la clase de módulo, debe registrarlos manualmente en el módulo para que SMP recopile todos los parámetros. Para registrar los parámetros en un módulo, utilice `smp.register_parameter(module, parameter)`.
```
class Module(torch.nn.Module):
def __init__(self, *args):
super().__init__(self, *args)
self.layer1 = Layer1()
self.layer2 = Layer2()
smp.register_parameter(self, self.layer1.weight)
def forward(self, input):
x = self.layer1(input)
# self.layer1.weight is required by self.layer2.forward
y = self.layer2(x, self.layer1.weight)
return y
```
### Configure el estimador SageMaker PyTorch
Al configurar un SageMaker PyTorch estimador en[Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python](model-parallel-sm-sdk.md), añada los parámetros para el paralelismo de datos fragmentados.
Para activar el paralelismo de datos fragmentados, añada el parámetro al estimador. `sharded_data_parallel_degree` SageMaker PyTorch Este parámetro especifica el número GPUs durante el cual se fragmenta el estado de entrenamiento. El valor de `sharded_data_parallel_degree` debe ser un número entero entre uno y el grado de paralelismo de los datos y debe dividir el grado de paralelismo de los datos de manera uniforme. Tenga en cuenta que la biblioteca detecta automáticamente el número de, GPUs por lo que el grado de paralelismo de los datos. Los siguientes parámetros adicionales están disponibles para configurar el paralelismo de datos partidos.
+ `"sdp_reduce_bucket_size"`*(int, predeterminado: 5e8)*: especifica el tamaño de los [cubos de gradiente del PyTorch DDP](https://pytorch.org/docs/stable/notes/ddp.html#internal-design) en cuanto al número de elementos del tipo d predeterminado.
+ `"sdp_param_persistence_threshold"`*(int, predeterminado: 1e6):* especifica el tamaño de un tensor de parámetros en cuanto al número de elementos que pueden permanecer en cada GPU. El paralelismo de datos fragmentados divide cada tensor de parámetros en un grupo paralelo de GPUs datos. Si el número de elementos en el tensor de parámetros es menor que este umbral, el tensor de parámetros no se divide; esto ayuda a reducir la sobrecarga de comunicación porque el tensor de parámetros se replica en el paralelo de datos. GPUs
+ `"sdp_max_live_parameters"`*(int, predeterminado: 1e9)*: especifica el número máximo de parámetros que pueden estar simultáneamente en un estado de entrenamiento recombinado durante la pasada hacia adelante y hacia atrás. La búsqueda de parámetros con la operación `AllGather` se detiene cuando el número de parámetros activos alcanza el umbral indicado. Tenga en cuenta que al aumentar este parámetro se incrementa el consumo de memoria.
+ `"sdp_hierarchical_allgather"` *(bool, predeterminado: true)*: si se establece en `True`, la operación `AllGather` se ejecuta jerárquicamente; se ejecuta dentro de cada nodo primero, y luego se ejecuta a través de todos los nodos. En el caso de los trabajos de entrenamiento distribuidos con varios nodos, la operación `AllGather` jerárquica se activa automáticamente.
+ `"sdp_gradient_clipping"` *(float, predeterminado: 1.0)*: especifica un umbral para recortar en gradiente la norma L2 de los gradientes antes de propagarlos hacia atrás a través de los parámetros del modelo. Cuando se activa el paralelismo de datos partidos, también se activa el recorte por gradiente. El umbral por defecto es `1.0`. Ajuste este parámetro si tiene el problema de la explosión de los gradientes.
El siguiente código muestra un ejemplo de cómo configurar el paralelismo de datos partidos.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
# "pipeline_parallel_degree": 1, # Optional, default is 1
# "tensor_parallel_degree": 1, # Optional, default is 1
"ddp": True,
# parameters for sharded data parallelism
"sharded_data_parallel_degree": 2, # Add this to activate sharded data parallelism
"sdp_reduce_bucket_size": int(5e8), # Optional
"sdp_param_persistence_threshold": int(1e6), # Optional
"sdp_max_live_parameters": int(1e9), # Optional
"sdp_hierarchical_allgather": True, # Optional
"sdp_gradient_clipping": 1.0 # Optional
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-job"
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Configuraciones de referencia
El equipo de formación SageMaker distribuido proporciona las siguientes configuraciones de referencia que puede utilizar como punto de partida. Puede extrapolar las siguientes configuraciones para experimentar y estimar el uso de memoria de la GPU para configurar su modelo.
Paralelismo de datos partidos con colectivos SMDDP
| Modelo/número de parámetros | Número de instancias | Tipo de instancia | Longitud de secuencia | Tamaño de lote global | Tamaño de minilote | Grado de paralelismo de datos partidos |
| --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-20B | 2 | ml.p4d.24xlarge | 2048 | 64 | 4 | 16 |
| GPT-NEOX-20B | 8 | ml.p4d.24xlarge | 2048 | 768 | 12 | 32 |
Por ejemplo, si aumenta la longitud de secuencia de un modelo de 20 000 millones de parámetros o aumenta el tamaño del modelo a 65 000 millones de parámetros, primero debe intentar reducir el tamaño del lote. Si el modelo sigue sin ajustarse al tamaño de lote más pequeño (el tamaño de lote de 1), intente aumentar el grado de paralelismo de modelos.
Paralelismo de datos partidos con paralelismo de tensores y colectivos NCCL
| Modelo/número de parámetros | Número de instancias | Tipo de instancia | Longitud de secuencia | Tamaño de lote global | Tamaño de minilote | Grado de paralelismo de datos partidos | Grado de tensor paralelo | Descarga de activación |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 2048 | 512 | 8 | 16 | 8 | Y |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 4096 | 512 | 2 | 64 | 2 | Y |
El uso combinado del paralelismo de datos fragmentados y el paralelismo tensorial resulta útil cuando se quiere incluir un modelo de lenguaje (LLM) de gran tamaño en un clúster a gran escala y, al mismo tiempo, utilizar datos de texto con una longitud de secuencia más larga, lo que lleva a utilizar un tamaño de lote más pequeño y, por lo tanto, gestionar el uso de la memoria de la GPU para entrenar con secuencias de texto más largas. LLMs Para obtener más información, consulte [Paralelismo de datos partidos con paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
Para ver casos prácticos, puntos de referencia y más ejemplos de configuración, consulte la entrada del blog [Nuevas mejoras de rendimiento en la biblioteca paralela de modelos Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
## Paralelismo de datos partidos con colectivos SMDDP
La biblioteca SageMaker de paralelismo de datos ofrece primitivas de comunicación colectiva (colectivos SMDDP) optimizadas para la infraestructura. AWS Logra la optimización al adoptar un patrón de all-to-all-type comunicación mediante el uso del [Elastic Fabric Adapter (EFA)](https://aws.amazon.com/hpc/efa/), lo que da como resultado colectivos de alto rendimiento y menos sensibles a la latencia, lo que descarga el procesamiento relacionado con la comunicación a la CPU y libera los ciclos de la GPU para el cálculo. En clústeres grandes, los colectivos SMDDP pueden ofrecer mejoras de hasta un 40 % en el rendimiento de los entrenamientos distribuidos en comparación con los NCCL. Para ver casos prácticos y resultados comparativos, consulte el blog [Nuevas mejoras de rendimiento en la biblioteca de paralelismo de modelos de SageMaker IA de Amazon](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
**nota**
El paralelismo de datos fragmentados con SMDDP Collectives está disponible en la biblioteca de paralelismo de SageMaker modelos, versión 1.13.0 y versiones posteriores, y en la biblioteca de paralelismo de datos, versión 1.6.0 y versiones posteriores. SageMaker Consulte también [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config) para utilizar el paralelismo de datos partidos con los colectivos SMDDP.
En el paralelismo de datos partidos, que es una técnica de uso común en el entrenamiento distribuido a gran escala, el colectivo `AllGather` se utiliza para reconstituir los parámetros de la capa partida para los cálculos de la pasada hacia adelante y hacia atrás, en paralelo con el cálculo de la GPU. En el caso de los modelos de gran tamaño, es fundamental realizar la operación `AllGather` de forma eficiente para evitar problemas con la GPU y reducir la velocidad de entrenamiento. Cuando se activa el paralelismo de datos partidos, los colectivos SMDDP se agrupan en estos colectivos `AllGather` fundamentales para el rendimiento, lo que mejora el rendimiento del entrenamiento.
**Entrenar con colectivos SMDDP**
Cuando su trabajo de entrenamiento tenga activado el paralelismo de datos partidos y cumpla con [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config), los colectivos SMDDP se activarán automáticamente. Internamente, los colectivos SMDDP optimizan el colectivo para que funcione en la infraestructura y recurren a la NCCL para todos los demás colectivos. `AllGather` AWS Además, en configuraciones no compatibles, todos los colectivos, incluidos `AllGather`, utilizan automáticamente el backend de los NCCL.
A partir de la versión 1.13.0 de la biblioteca de paralelismo de SageMaker modelos, el parámetro se añade a las opciones. `"ddp_dist_backend"` `modelparallel` El valor predeterminado de este parámetro de configuración es `"auto"`, que utiliza los colectivos SMDDP siempre que sea posible y, de lo contrario, recurre a los NCCL. Para forzar a la biblioteca a utilizar siempre los NCCL, especifique `"nccl"` en el parámetro de configuración `"ddp_dist_backend"`.
El siguiente ejemplo de código muestra cómo configurar un PyTorch estimador utilizando el paralelismo de datos fragmentados con el `"ddp_dist_backend"` parámetro, que está establecido en forma predeterminada y, por lo tanto, su adición es opcional. `"auto"`
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": {
"partitions": 1,
"ddp": True,
"sharded_data_parallel_degree": 64
"bf16": True,
"ddp_dist_backend": "auto" # Specify "nccl" to force to use NCCL.
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Configuraciones admitidas**
La operación `AllGather` con los colectivos SMDDP se activa en los trabajos de entrenamiento cuando se cumplen todos los requisitos de configuración siguientes.
+ El grado de paralelismo de los datos partidos es superior a 1
+ `Instance_count` mayor que 1
+ `Instance_type` igual a `ml.p4d.24xlarge`
+ SageMaker contenedor de entrenamiento para la versión 1.12.1 o posterior PyTorch
+ La biblioteca de paralelismo SageMaker de datos v1.6.0 o posterior
+ La biblioteca de paralelismo de SageMaker modelos v1.13.0 o posterior
**Ajuste del rendimiento y de la memoria**
Los colectivos SMDDP utilizan memoria de GPU adicional. Existen dos variables de entorno para configurar el uso de la memoria de la GPU en función de los diferentes casos de uso de entrenamiento de modelos.
+ `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` Durante la operación `AllGather` SMDDP, el búfer de entrada `AllGather` se copia en un búfer temporal para la comunicación entre nodos. La variable `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` controla el tamaño (en bytes) de este búfer temporal. Si el tamaño del búfer temporal es menor que el tamaño del búfer de entrada `AllGather`, el colectivo `AllGather` recurre a los NCCL.
+ Valor predeterminado: 16 \$1 1024 \$1 1024 (16 MB)
+ Valores aceptables: cualquier múltiplo de 8192
+ `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` La variable `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` consiste en dimensionar el búfer temporal (en bytes) para almacenar los datos recopilados de la comunicación entre nodos. Si el tamaño de este búfer temporal es inferior a `1/8 * sharded_data_parallel_degree * AllGather input size`, el colectivo `AllGather` recurre a los NCCL.
+ Valor predeterminado: 128 \$1 1024 \$1 1024 (128 MB)
+ Valores aceptables: cualquier múltiplo de 8192
**Guía de ajuste de las variables de tamaño del búfer**
Los valores predeterminados de las variables de entorno deberían funcionar bien en la mayoría de los casos de uso. Recomendamos ajustar estas variables solo si en el entrenamiento se produce el error (OOM). out-of-memory
En la siguiente lista, se describen algunos consejos de ajuste para reducir el consumo de memoria de la GPU de los colectivos SMDDP y, al mismo tiempo, conservar la ganancia de rendimiento que generan.
+ Ajustar `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`
+ El tamaño del búfer de entrada `AllGather` es menor para los modelos más pequeños. Por lo tanto, el tamaño requerido para `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` puede ser menor para los modelos con menos parámetros.
+ El tamaño del búfer de `AllGather` entrada disminuye a medida que `sharded_data_parallel_degree` aumenta, ya que el modelo se fragmenta más. GPUs Por lo tanto, el tamaño requerido para `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` puede ser menor para tareas de entrenamiento con valores grandes para `sharded_data_parallel_degree`.
+ Ajustar `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`
+ La cantidad de datos recopilados de la comunicación entre nodos es menor para los modelos con menos parámetros. Por lo tanto, el tamaño requerido para `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` puede ser menor para estos modelos con un número menor de parámetros.
Es posible que algunos colectivos recurran a los NCCL; por lo tanto, es posible que no consiga el rendimiento de los colectivos SMDDP optimizados. Si hay memoria de GPU adicional disponible para su uso, puede considerar la posibilidad de aumentar los valores de `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` y `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` para aprovechar la ganancia de rendimiento.
El siguiente código muestra cómo configurar las variables de entorno agregándolas al parámetro `mpi_options` de distribución del estimador. PyTorch
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
.... # All modelparallel configuration options go here
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
# Use the following two lines to tune values of the environment variables for buffer
mpioptions += " -x SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES=8192"
mpioptions += " -x SMDDP_AG_SORT_BUFFER_SIZE_BYTES=8192"
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo-with-tuning",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Entrenamiento de precisión mixto con paralelismo de datos partidos
Para ahorrar aún más memoria en la GPU con números de punto flotante de precisión media y paralelismo de datos fragmentados, puede activar el formato de punto flotante de 16 bits (FP16) o el formato de [punto flotante Brain](https://en.wikichip.org/wiki/brain_floating-point_format) (BF16) añadiendo un parámetro adicional a la configuración de entrenamiento distribuido.
**nota**
El entrenamiento de precisión mixta con paralelismo de datos fragmentados está disponible en la biblioteca de paralelismo de modelos, versión 1.11.0 y versiones posteriores. SageMaker
** FP16 Para el entrenamiento con paralelismo de datos fragmentados**
Para ejecutar el FP16 entrenamiento con paralelismo de datos fragmentados, agréguelo al diccionario de configuración. `"fp16": True"` `smp_options` En el script de su entrenamiento, puede elegir entre las opciones de escalado de pérdidas estáticas y dinámicas a través del módulo `smp.DistributedOptimizer`. Para obtener más información, consulte [FP16 Entrenamiento con paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md).
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"fp16": True
}
}
```
**Para BF16 entrenar con paralelismo de datos fragmentados**
La función de paralelismo de datos fragmentados de la IA permite el entrenamiento en tipos de datos. SageMaker BF16 El tipo de BF16 datos usa 8 bits para representar el exponente de un número de coma flotante, mientras que el tipo de FP16 datos usa 5 bits. Conservar los 8 bits del exponente permite mantener la misma representación del exponente de un número de coma flotante () de precisión simple de 32 bits. FP32 Esto hace que la conversión entre un FP32 y otro sea BF16 más sencilla y mucho menos propensa a provocar problemas de desbordamiento o subflujo que suelen surgir durante el FP16 entrenamiento, especialmente cuando se entrenan modelos más grandes. Si bien ambos tipos de datos utilizan 16 bits en total, este aumento del rango de representación del exponente en el BF16 formato se produce a expensas de una menor precisión. Para el entrenamiento de modelos grandes, esta precisión reducida suele considerarse una compensación aceptable entre el alcance y la estabilidad del entrenamiento.
**nota**
Actualmente, el BF16 entrenamiento solo funciona cuando el paralelismo de datos fragmentados está activado.
Para ejecutar el BF16 entrenamiento con paralelismo de datos fragmentados, añádalo al diccionario de configuración. `"bf16": True` `smp_options`
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"bf16": True
}
}
```
## Paralelismo de datos partidos con paralelismo de tensores
Si utiliza el paralelismo de datos partidos y también necesita reducir el tamaño del lote global, considere la posibilidad de utilizar el [paralelismo de tensores](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-tensor-parallelism.html) con el paralelismo de datos partidos. Al entrenar un modelo grande con paralelismo de datos partidos en un clúster de procesamiento muy grande (normalmente 128 nodos o más), incluso un tamaño de lote pequeño por GPU da como resultado un tamaño de lote global muy grande. Puede provocar problemas de convergencia o problemas de bajo rendimiento computacional. En ocasiones, no es posible reducir el tamaño del lote por GPU solo con el paralelismo de datos partidos si un solo lote ya es grande y no puede reducirse más. En estos casos, el uso del paralelismo de datos partidos en combinación con el paralelismo de tensores ayuda a reducir el tamaño del lote global.
La elección de los grados paralelos y tensoriales paralelos óptimos para los datos partidos depende de la escala del modelo, el tipo de instancia y el tamaño del lote global que sea razonable para que el modelo converja. Le recomendamos que comience con un grado de tensor paralelo bajo para ajustar el tamaño del lote global al clúster de procesamiento a fin de resolver los out-of-memory errores de CUDA y lograr el mejor rendimiento. Consulte los dos casos de ejemplo siguientes para saber cómo la combinación de paralelismo tensorial y paralelismo de datos fragmentados le ayuda a ajustar el tamaño del lote global mediante la agrupación GPUs según el paralelismo del modelo, lo que se traduce en un menor número de réplicas de modelos y un tamaño de lote global más pequeño.
**nota**
Esta función está disponible en la biblioteca de paralelismo de modelos, versión 1.15, y es compatible con la versión 1.13.1. SageMaker PyTorch
**nota**
Esta característica está disponible para los modelos compatibles mediante la funcionalidad de paralelismo de tensores de la biblioteca. Para ver la lista de modelos compatibles, consulte [Soporte listo para usar modelos Hugging Face Transformer](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-hugging-face.html). Tenga en cuenta también que debe pasar `tensor_parallelism=True` al argumento `smp.model_creation` mientras modifica el script de su entrenamiento. *Para obtener más información, consulte el guion de formación en el repositorio de ejemplos de IA. [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793)SageMaker GitHub *
### Ejemplo 1
Supongamos que queremos entrenar un modelo sobre un clúster de 1536 GPUs (192 nodos con 8 GPUs en cada uno), estableciendo el grado de paralelismo de los datos fragmentados en 32 (`sharded_data_parallel_degree=32`) y el tamaño del lote por GPU en 1, donde cada lote tiene una longitud de secuencia de 4096 fichas. En este caso, hay 1536 réplicas de modelos, el tamaño del lote global pasa a ser 1536 y cada lote global contiene unos 6 millones de tokens.
```
(1536 GPUs) * (1 batch per GPU) = (1536 global batches)
(1536 batches) * (4096 tokens per batch) = (6,291,456 tokens)
```
Si se le añade un paralelismo de tensores, se puede reducir el tamaño del lote global. Un ejemplo de configuración puede ser establecer el grado de paralelismo del tensor en 8 y el tamaño del lote por GPU en 4. Esto forma 192 grupos tensoriales paralelos o 192 réplicas de modelos, donde cada réplica de modelo se distribuye en 8. GPUs El tamaño del lote de 4 es la cantidad de datos de entrenamiento por iteración y por grupo de tensores paralelos; es decir, cada réplica del modelo consume 4 lotes por iteración. En este caso, el tamaño del lote global pasa a ser 768 y cada lote global contiene unos 3 millones de tokens. Por lo tanto, el tamaño del lote global se reduce a la mitad en comparación con el caso anterior solo con el paralelismo de datos partidos.
```
(1536 GPUs) / (8 tensor parallel degree) = (192 tensor parallelism groups)
(192 tensor parallelism groups) * (4 batches per tensor parallelism group) = (768 global batches)
(768 batches) * (4096 tokens per batch) = (3,145,728 tokens)
```
### Ejemplo 2
Cuando se activan tanto el paralelismo de datos partidos como el paralelismo de tensores, la biblioteca primero aplica el paralelismo de tensores y parte el modelo en esta dimensión. Para cada rango paralelo tensorial, el paralelismo de datos se aplica según `sharded_data_parallel_degree`.
Por ejemplo, supongamos que queremos establecer 32 GPUs con un grado de paralelo tensorial de 4 (formando grupos de 4 GPUs), un grado de paralelo de datos fragmentados de 4 y terminando con un grado de replicación de 2. La asignación crea ocho grupos de GPU en función del grado paralelo del tensor de la siguiente manera: `(0,1,2,3)`, `(4,5,6,7)`, `(8,9,10,11)`, `(12,13,14,15)`, `(16,17,18,19)`, `(20,21,22,23)`, `(24,25,26,27)`, `(28,29,30,31)`. Es decir, cuatro GPUs forman un grupo tensorial paralelo. En este caso, el grupo paralelo de datos reducido para el rango 0 GPUs de los grupos paralelos de tensores sería. `(0,4,8,12,16,20,24,28)` El grupo paralelo de datos reducido se fragmenta en función del grado de paralelo de datos fragmentados de 4, lo que da como resultado dos grupos de replicación para el paralelismo de datos. GPUs`(0,4,8,12)`forman un grupo de fragmentación, que en conjunto contienen una copia completa de todos los parámetros del rango 0 del tensor paralelo, GPUs `(16,20,24,28)` y forman otro grupo similar. Otros rangos paralelos tensoriales también tienen grupos de partición y replicación similares.
![\[Figura 1: grupos de paralelismo de tensores.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_tp.jpg)
Figura 1: grupos de paralelismo de tensores para (nodos, grado de paralelismo de datos particionados, grado de paralelismo de tensores) = (4, 4, 4), donde cada rectángulo representa una GPU con índices de 0 a 31. GPUs Forman grupos de paralelismo tensorial de TPG a TPG. 0 7 Los grupos de replicación son (\$1TPG0, TPG4\$1, \$1TPG1, TPG5\$1, \$1TPG2, TPG6\$1 y \$1TPG3, TPG7\$1); cada par de grupos de replicación comparte el mismo color pero se rellena de forma diferente.
![\[Figura 2: grupos de paralelismo de datos particionados.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_sdp.jpg)
Figura 2: grupos de paralelismo de datos particionados para (nodos, grado de paralelismo de datos particionados, grado de paralelismo de tensores) = (4, 4, 4), donde cada rectángulo representa una GPU con índices de 0 a 31. La GPUs forma agrupa el paralelismo de datos fragmentados de SDPG a SDPG. 0 7 Los grupos de replicación son (\$1SDPG0, SDPG4\$1, \$1SDPG1, SDPG5\$1, \$1SDPG2, SDPG6\$1 y \$1SDPG3, SDPG7\$1); cada par de grupos de replicación comparte el mismo color pero se rellena de forma diferente.
### Cómo activar el paralelismo de datos partidos con el paralelismo de tensores
Para utilizar el paralelismo de datos fragmentados con el paralelismo tensorial, es necesario establecer ambos `sharded_data_parallel_degree` parámetros y en la configuración para la que se va a crear un objeto de la clase de estimador. `tensor_parallel_degree` `distribution` SageMaker PyTorch
También debe activar `prescaled_batch`. Esto significa que, en lugar de que cada GPU lea su propio lote de datos, cada grupo paralelo de tensores leerá colectivamente un lote combinado del tamaño de lote elegido. Efectivamente, en lugar de dividir el conjunto de datos en partes iguales al número de GPUs (o tamaño paralelo de los datos`smp.dp_size()`), se divide en partes iguales al número de GPUs dividido por `tensor_parallel_degree` (también denominado tamaño paralelo de datos reducido`smp.rdp_size()`). Para obtener más información sobre el lote preescalado, consulte Lote [preescalado en la documentación](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#prescaled-batch) del SDK de *SageMaker Python*. *Consulta también el ejemplo de script de entrenamiento [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164)para la GPT-2 en el repositorio de ejemplos de IA. SageMaker GitHub *
El siguiente fragmento de código muestra un ejemplo de creación de un objeto PyTorch estimador basado en el escenario mencionado anteriormente en. [Ejemplo 2](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism-ex2)
```
mpi_options = "-verbose --mca orte_base_help_aggregate 0 "
smp_parameters = {
"ddp": True,
"fp16": True,
"prescaled_batch": True,
"sharded_data_parallel_degree": 4,
"tensor_parallel_degree": 4
}
pytorch_estimator = PyTorch(
entry_point="your_training_script.py",
role=role,
instance_type="ml.p4d.24xlarge",
volume_size=200,
instance_count=4,
sagemaker_session=sagemaker_session,
py_version="py3",
framework_version="1.13.1",
distribution={
"smdistributed": {
"modelparallel": {
"enabled": True,
"parameters": smp_parameters,
}
},
"mpi": {
"enabled": True,
"processes_per_host": 8,
"custom_mpi_options": mpi_options,
},
},
source_dir="source_directory_of_your_code",
output_path=s3_output_location
)
```
## Consejos y consideraciones a tener en cuenta para utilizar el paralelismo de datos partidos
Tenga en cuenta lo siguiente al utilizar el paralelismo de datos fragmentados de la SageMaker biblioteca de paralelismo de modelos.
+ El paralelismo de datos fragmentados es compatible con el entrenamiento. FP16 Para ejecutar el FP16 entrenamiento, consulta la sección. [FP16 Entrenamiento con paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md)
+ El paralelismo de datos partidos es compatible con el paralelismo de tensores. Es posible que deba tener en cuenta los siguientes elementos para utilizar el paralelismo de datos partidos con el paralelismo de tensores.
+ Al utilizar el paralelismo de datos partidos con el paralelismo de tensores, las capas incrustadas también se distribuyen automáticamente en el grupo tensorial paralelo. En otras palabras, el parámetro `distribute_embedding` se establece automáticamente en `True`. Para obtener más información sobre el paralelismo de tensores, consulte [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
+ Tenga en cuenta que el paralelismo de datos partidos con el paralelismo de tensores utiliza actualmente los colectivos NCCL como base de la estrategia de entrenamiento distribuido.
Para obtener más información, consulte la sección [Paralelismo de datos partidos con paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
+ El paralelismo de datos partidos actualmente no es compatible con el [paralelismo de canalización](model-parallel-intro.md#model-parallel-intro-pp) o la [partición del estado del optimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md). Para activar el paralelismo de datos partidos, desactive la partición del estado del optimizador y establezca el grado de paralelo de la canalización en 1.
+ Las funciones de [verificación de activación](model-parallel-extended-features-pytorch-activation-checkpointing.md) y [descarga de activación](model-parallel-extended-features-pytorch-activation-offloading.md) son compatibles con el paralelismo de datos partidos.
+ Para utilizar el paralelismo de datos partidos con la acumulación de gradientes, defina el argumento `backward_passes_per_step` en función del número de pasos de acumulación mientras agrupa el modelo con el módulo [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel). Esto garantiza que la operación `AllReduce` de gradiente en todos los grupos de replicación del modelo (grupos de partición) se lleve a cabo en el límite de acumulación de gradientes.
+ Puede comprobar sus modelos entrenados con paralelismo de datos fragmentados mediante los puntos de control de la biblioteca, y. APIs `smp.save_checkpoint` `smp.resume_from_checkpoint` Para obtener más información, consulte [Verificación de un PyTorch modelo distribuido (para la biblioteca de paralelismo de SageMaker modelos v1.10.0 y versiones posteriores)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-checkpoint).
+ El comportamiento del parámetro de configuración [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) cambia con el paralelismo de datos partidos. Cuando estas dos funciones se activan simultáneamente, los parámetros se inicializan inmediatamente al crear el modelo de forma partida, en lugar de retrasar la inicialización de los parámetros, de modo que cada rango se inicializa y almacena su propia partición de parámetros.
+ Cuando se activa el paralelismo de datos partidos, la biblioteca recorta el gradiente internamente al ejecutar la llamada `optimizer.step()`. No es necesario utilizar una utilidad APIs para recortar con gradientes, como. [https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html) Para ajustar el valor límite para el recorte de gradiente, puede establecerlo mediante el `sdp_gradient_clipping` parámetro de la configuración del parámetro de distribución al construir el SageMaker PyTorch estimador, como se muestra en la sección. [Cómo aplicar el paralelismo de datos partidos a su trabajo de entrenamiento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
# Canalización de un modelo
Una de las características principales de la biblioteca de paralelismo SageMaker de modelos es el paralelismo de *canalización*, que determina el orden en que se realizan los cálculos y se procesan los datos en todos los dispositivos durante el entrenamiento del modelo. La canalización es una técnica que permite lograr una verdadera paralelización en el paralelismo del modelo, ya que permite GPUs procesar simultáneamente diferentes muestras de datos y superar la pérdida de rendimiento provocada por el cálculo secuencial. Al utilizar el paralelismo de canalización, el trabajo de entrenamiento se ejecuta de forma escalonada en microlotes para maximizar el uso de la GPU.
**nota**
El paralelismo por canalización, también denominado particionamiento de modelos, está disponible tanto para como para. PyTorch TensorFlow Para las versiones compatibles de los marcos, consulte [Marcos compatibles y Regiones de AWS](distributed-model-parallel-support.md).
## Programa de ejecución de canalización
La canalización se basa en dividir un minilote en microlotes, que se introducen en el proceso de formación one-by-one y siguen un programa de ejecución definido por el tiempo de ejecución de la biblioteca. Un *microlote* es un subconjunto más pequeño de un minilote de entrenamiento determinado. El programa de canalización determina qué microlote ejecuta cada dispositivo en cada intervalo de tiempo.
Por ejemplo, según el cronograma de procesamiento y la partición del modelo, la GPU `i` puede realizar el cálculo (hacia adelante o hacia atrás) en microlotes, `b` mientras que la GPU `i+1` realiza el cálculo en microlotes`b+1`, manteniendo así ambos activos al mismo tiempo. GPUs Durante una sola pasada hacia adelante o hacia atrás, el flujo de ejecución de un único microlote puede visitar el mismo dispositivo varias veces, en función de la decisión de división. Por ejemplo, una operación que se realiza al principio del modelo se puede colocar en el mismo dispositivo que una operación al final del modelo, mientras que las operaciones intermedias se realizan en diferentes dispositivos, lo que significa que este dispositivo se visita dos veces.
La biblioteca ofrece dos programas de canalización diferentes, *simples* e *intercalados*, que se pueden configurar mediante el `pipeline` parámetro del SDK de SageMaker Python. En la mayoría de los casos, la canalización intercalada puede lograr un mejor rendimiento al utilizarla de manera más eficiente. GPUs
### Canalización intercalada
En una canalización intercalada, se prioriza la ejecución inversa de los microlotes siempre que sea posible. Esto permite liberar más rápidamente la memoria utilizada para las activaciones, lo que permite utilizar la memoria de manera más eficiente. También permite aumentar el número de microlotes, lo que reduce el tiempo de inactividad del. GPUs En estado estable, cada dispositivo alterna entre pasadas hacia adelante y hacia atrás. Esto significa que la pasada hacia atrás de un microlote puede transcurrir antes de que finalice la pasada hacia adelante de otro microlote.
![\[Ejemplo de cronograma de ejecución para la tubería intercalada superior a 2. GPUs\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-execution.png)
La figura anterior ilustra un ejemplo de programa de ejecución para la canalización intercalada a lo largo de 2. GPUs En dicha figura, F0 representa la pasada hacia adelante para el microlote 0 y B1 representa la pasada hacia atrás para el microlote 1. La **actualización** representa la actualización de los parámetros por parte del optimizador. GPU0 siempre que es posible, prioriza las pasadas hacia atrás (por ejemplo, ejecuta B0 antes que F2), lo que permite borrar la memoria utilizada para las activaciones anteriores.
### Canalización sencilla
Por el contrario, una canalización simple termina de ejecutar la pasada hacia adelante para cada microlote antes de iniciar la pasada hacia atrás. Esto significa que solo canaliza la pasada hacia adelante y la pasada hacia atrás dentro de sí misma. La siguiente figura ilustra un ejemplo de cómo funciona, en lugar de 2. GPUs
![\[Ejemplo en una canalización que ejecuta la pasada hacia adelante para cada microlote antes de iniciar la pasada hacia atrás.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/simple-pipeline-execution.png)
### Canalización de la ejecución en marcos específicos
Utilice las siguientes secciones para obtener información sobre las decisiones de programación de canalizaciones específicas del marco que utiliza SageMaker la biblioteca de paralelismo modelo para y. TensorFlow PyTorch
#### Pipeline Execution con TensorFlow
La siguiente imagen es un ejemplo de un TensorFlow gráfico dividido por la biblioteca de paralelismo de modelos, mediante la división automática de modelos. Al dividir un gráfico, cada subgráfico resultante se replica B veces (excepto las variables), donde B es el número de microlotes. En esta figura, cada subgráfico se repite 2 veces (B=2). Se inserta una operación `SMPInput` en cada entrada de un subgráfico y se inserta una operación `SMPOutput` en cada salida. Estas operaciones se comunican con el servidor de la biblioteca para transferir los tensores entre sí.
![\[Ejemplo de una TensorFlow gráfica particionada por la biblioteca de paralelismo de modelos, mediante la división automática de modelos.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.png)
La siguiente imagen es un ejemplo de 2 subgráficos divididos por B=2 con operaciones de gradiente añadidas. El gradiente de una operación `SMPInput` es una operación `SMPOutput` y viceversa. Esto permite que los gradientes fluyan hacia atrás durante la retropropagación.
![\[Ejemplo de dos subgráficos divididos por B=2 con operaciones de gradiente añadidas.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.gif)
Este GIF muestra un ejemplo de un programa de ejecución de tuberías intercalado con B=2 microlotes y 2 subgráficos. Cada dispositivo ejecuta secuencialmente una de las réplicas de los subgráficos para mejorar el uso de la GPU. A medida que B crece, la fracción de los intervalos de tiempo de inactividad se reduce a cero. Siempre que llegue el momento de realizar un cálculo (hacia adelante o hacia atrás) en una réplica de subgráfico específica, la capa de canalización envía señales a las operaciones `SMPInput` azules correspondientes para que comiencen a ejecutarse.
Una vez calculados los gradientes de todos los microlotes de un único minilote, la biblioteca combina los gradientes de todos los microlotes para luego aplicarlos a los parámetros.
#### Pipeline Execution con PyTorch
Conceptualmente, la canalización sigue una idea similar en. PyTorch Sin embargo, dado que PyTorch no incluye gráficos estáticos, la PyTorch función de la biblioteca de paralelismo de modelos utiliza un paradigma de canalización más dinámico.
Por ejemplo TensorFlow, cada lote se divide en varios microlotes, que se ejecutan uno a la vez en cada dispositivo. Sin embargo, el programa de ejecución se gestiona a través de servidores de ejecución lanzados en cada dispositivo. Siempre que se necesite la salida de un submódulo colocado en otro dispositivo en el dispositivo actual, se envía una solicitud de ejecución al servidor de ejecución del dispositivo remoto junto con los tensores de entrada al submódulo. Luego, el servidor ejecuta este módulo con las entradas dadas y devuelve la respuesta al dispositivo actual.
Como el dispositivo actual está inactivo durante la ejecución remota del submódulo, la ejecución local del microlote actual se detiene y el tiempo de ejecución de la biblioteca cambia la ejecución a otro microlote en el que el dispositivo actual puede trabajar activamente. La priorización de los microlotes viene determinada por el programa de canalización elegido. En el caso de un programa de canalización intercalado, siempre que sea posible, se prioriza los microlotes que se encuentran en la fase anterior del cálculo.
# Paralelismo de tensores
El *paralelismo de tensores* es un tipo de paralelismo de modelos en el que las ponderaciones, gradientes y estados del optimizador específicos del modelo se dividen entre los dispositivos. A diferencia del paralelismo por canalización, que mantiene intactos las ponderaciones individuales pero divide el *conjunto* de ponderaciones, el paralelismo de tensores divide las ponderaciones individuales. Por lo general, esto implica el cálculo distribuido de operaciones, módulos o capas específicos del modelo.
El paralelismo de tensores es necesario en los casos en los que un único parámetro consume la mayor parte de la memoria de la GPU (por ejemplo, tablas de incrustación grandes con un gran tamaño de vocabulario o una capa softmax grande con un gran número de clases). En este caso, tratar este gran tensor u operación como una unidad atómica es ineficiente e impide equilibrar la carga de memoria.
El paralelismo de tensores también es útil para modelos extremadamente grandes en los que una canalización pura simplemente no es suficiente. Por ejemplo, con los modelos a escala GPT-3 que requieren dividir en decenas de instancias, una canalización pura por microlotes es ineficiente porque la profundidad de la canalización es demasiado alta y la sobrecarga se vuelve prohibitivamente grande.
**nota**
El paralelismo tensorial está disponible PyTorch en la biblioteca de SageMaker modelos de paralelismo v1.6.0 y versiones posteriores.
**Topics**
+ [Cómo funciona el paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism-how-it-works.md)
+ [Ejecute un trabajo de entrenamiento en paralelo de un modelo SageMaker distribuido con Tensor Paralelism](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md)
+ [Soporte listo para usar para modelos Hugging Face Transformer](model-parallel-extended-features-pytorch-hugging-face.md)
+ [Mecanismo de clasificación cuando se utiliza una combinación de paralelismo de canalización y paralelismo de tensores](model-parallel-extended-features-pytorch-ranking-mechanism.md)
# Cómo funciona el paralelismo de tensores
El paralelismo de tensores tiene lugar a nivel de `nn.Modules`; divide módulos específicos del modelo en rangos paralelos tensoriales. Esto se suma a la división existente del *conjunto de módulos* utilizados en el paralelismo de canalización.
Cuando un módulo se divide mediante paralelismo de tensores, se distribuye su propagación hacia adelante y hacia atrás. La biblioteca gestiona la comunicación necesaria entre los dispositivos para implementar la ejecución distribuida de estos módulos. Los módulos se dividen en varios rangos paralelos de datos. A diferencia de la distribución tradicional de cargas de trabajo, cada rango paralelo de datos **no** tiene la réplica completa del modelo cuando se utiliza el paralelismo de tensores de la biblioteca. En cambio, cada rango paralelo de datos puede tener solo una división de los módulos distribuidos, además de la totalidad de los módulos que no están distribuidos.
**Ejemplo:** considere el paralelismo de tensores en los rangos paralelos de datos, donde el grado de paralelismo de datos es 4 y el grado de paralelismo de tensores es 2. Supongamos que tiene un grupo paralelo de datos que contiene el siguiente árbol de módulos, después de dividir el conjunto de módulos.
```
A
├── B
| ├── E
| ├── F
├── C
└── D
├── G
└── H
```
Supongamos que el paralelismo de tensores es compatible con los módulos B, G y H. Un posible resultado de la división tensorial paralela de este modelo podría ser:
```
dp_rank 0 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 1 (tensor parallel rank 1): A, B:1, C, D, G:1, H
dp_rank 2 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 3 (tensor parallel rank 1): A, B:1, C, D, G:1, H
```
Cada línea representa el conjunto de módulos almacenados en ese `dp_rank`, y la notación `X:y` representa la fracción `y` del módulo `X`. Tenga en cuenta lo siguiente:
1. La división se lleva a cabo en subconjuntos de rangos paralelos de datos, que llamamos `TP_GROUP`, no todo el `DP_GROUP`, de modo que la división exacta del modelo se replica en `dp_rank` 0 y `dp_rank` 2, y de manera similar en `dp_rank` 1 y `dp_rank` 3.
1. Los módulos `E` y `F` ya no forman parte del modelo, ya que su módulo principal `B` está dividido, así como cualquier ejecución que sea normalmente una parte de `E` y `F` se lleva a cabo dentro del módulo `B` (dividido).
1. Si bien `H` es compatible con el paralelismo de tensores, en este ejemplo no está dividido, lo que pone de relieve que la posibilidad de dividir un módulo depende de la entrada del usuario. El hecho de que un módulo sea compatible con el paralelismo de tensores no significa necesariamente que esté dividido.
## Cómo adapta la biblioteca el PyTorch `nn.Linear` paralelismo tensorial al módulo
Cuando el paralelismo de tensores se realiza sobre rangos paralelos de datos, un subconjunto de los parámetros, gradientes y estados del optimizador se divide en los dispositivos tensoriales paralelos *para los módulos que están divididos.* En cuanto al resto de módulos, los dispositivos paralelos tensores funcionan de forma paralela y regular. Para ejecutar el módulo dividido, un dispositivo primero recopila las partes necesarias de *todas las muestras de datos* de los dispositivos homólogos del mismo grupo de paralelismo de tensores. Luego, el dispositivo ejecuta la fracción local del módulo en todas estas muestras de datos, seguida de otra ronda de sincronización que combina las partes de la salida de cada muestra de datos y devuelve las muestras de datos combinadas a la fuente de donde se originó la muestra GPUs de datos por primera vez. La siguiente figura muestra un ejemplo de este proceso en un módulo `nn.Linear` dividido.
![\[Dos figuras que muestran dos conceptos de paralelismo de tensores.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-concept.png)
La primera figura muestra un modelo pequeño con un módulo `nn.Linear`grande con paralelismo de datos en los dos rangos de paralelismo de tensores. El módulo `nn.Linear` se replica en los dos rangos paralelos.
La segunda figura muestra el paralelismo de tensores aplicado a un modelo más grande mientras se divide el módulo `nn.Linear`. Cada `tp_rank` contiene la mitad del módulo lineal y la totalidad del resto de las operaciones. Mientras se ejecuta el módulo lineal, cada `tp_rank` recopila la mitad correspondiente de todas las muestras de datos y la pasa a través de su mitad del módulo `nn.Linear`. El resultado debe estar disperso y reducido (con la suma como operación de reducción) para que cada rango tenga la salida lineal final de sus propias muestras de datos. El resto del modelo se ejecuta de forma paralela a los datos típicos.
# Ejecute un trabajo de entrenamiento en paralelo de un modelo SageMaker distribuido con Tensor Paralelism
En esta sección, aprenderá lo siguiente:
+ Cómo configurar un SageMaker PyTorch estimador y la opción de paralelismo del SageMaker modelo para utilizar el paralelismo tensorial.
+ Cómo adaptar el script de su entrenamiento mediante los módulos `smdistributed.modelparallel` ampliados para el paralelismo de tensores.
Para obtener más información sobre los `smdistributed.modelparallel` módulos, consulte el [SageMaker modelo parallel APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) en la *documentación del SDK de SageMaker Python*.
**Topics**
+ [Paralelismo tensorial por sí solo](#model-parallel-extended-features-pytorch-tensor-parallelism-alone)
+ [Paralelismo tensorial combinado con paralelismo de canalización](#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism)
## Paralelismo tensorial por sí solo
A continuación se muestra un ejemplo de una opción de entrenamiento distribuido para activar solo el paralelismo de tensores, sin el paralelismo de canalización. Configure los `smp_options` diccionarios `mpi_options` y para especificar las opciones de entrenamiento distribuidas en el SageMaker `PyTorch` estimador.
**nota**
Las funciones ampliadas de ahorro de memoria están disponibles a través de Deep Learning Containers for PyTorch, que implementa la biblioteca de paralelismo de SageMaker modelos v1.6.0 o posterior.
**Configure un estimador SageMaker PyTorch **
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"pipeline_parallel_degree": 1, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 4, # tp over 4 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**sugerencia**
Para encontrar una lista completa de parámetros`distribution`, consulte Parámetros de [configuración para el paralelismo de modelos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html) en la documentación del SDK de SageMaker Python.
**Adapta tu guion de entrenamiento PyTorch **
El siguiente ejemplo de guion de entrenamiento muestra cómo adaptar la biblioteca de paralelismo de SageMaker modelos a un guion de entrenamiento. En este ejemplo, se asume que el script se llama `your_training_script.py`.
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
loss.backward()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64)
# smdistributed: Enable tensor parallelism for all supported modules in the model
# i.e., nn.Linear in this case. Alternatively, we can use
# smp.set_tensor_parallelism(model.fc1, True)
# to enable it only for model.fc1
with smp.tensor_parallelism():
model = Net()
# smdistributed: Use the DistributedModel wrapper to distribute the
# modules for which tensor parallelism is enabled
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Paralelismo tensorial combinado con paralelismo de canalización
El siguiente es un ejemplo de una opción de entrenamiento distribuida que permite combinar el paralelismo tensorial con el paralelismo en canalización. Configure los `smp_options` parámetros `mpi_options` y para especificar las opciones paralelas del modelo con paralelismo tensorial al configurar un estimador. SageMaker `PyTorch`
**nota**
Las funciones ampliadas de ahorro de memoria están disponibles a través de Deep Learning Containers for PyTorch, que implementa la biblioteca de paralelismo de SageMaker modelos v1.6.0 o posterior.
**Configure un estimador SageMaker PyTorch **
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Adapta tu guion de entrenamiento PyTorch **
El siguiente ejemplo de guion de entrenamiento muestra cómo adaptar la biblioteca de paralelismo de SageMaker modelos a un guion de entrenamiento. Tenga en cuenta que el script de entrenamiento ahora incluye el decorador `smp.step`:
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = Net()
# smdistributed: enable tensor parallelism only for model.fc1
smp.set_tensor_parallelism(model.fc1, True)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
# Soporte listo para usar para modelos Hugging Face Transformer
El paralelismo tensorial de la biblioteca de paralelismo de SageMaker modelos es compatible con los siguientes modelos de Hugging Face out-of-the-box Transformer:
+ GPT-2, BERT y Ro BERTa (disponibles en la biblioteca de paralelismo de modelos v1.7.0 y versiones posteriores) SageMaker
+ GPT-J (disponible en la biblioteca de paralelismo de modelos v1.8.0 y versiones posteriores) SageMaker
+ GPT-neo (disponible en la biblioteca de paralelismo de modelos v1.10.0 y versiones posteriores) SageMaker
**nota**
Para cualquier otro modelo de Transformers, debe usar la API [smdistributed.modelparallel.torch.tp\$1register\$1with\$1module ()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tp_register_with_module) para aplicar el paralelismo de tensores.
**nota**
Para usar el paralelismo tensorial para entrenar modelos de Hugging Face Transformer, asegúrate de usar Hugging Face Deep Learning Containers, que tengan la biblioteca de paralelismo de modelos PyTorch v1.7.0 y versiones posteriores. SageMaker [Para obtener más información, consulte las notas de versión de la biblioteca de paralelismo de modelos. SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html)
## Modelos compatibles listos para usar
Para los modelos de transformadores Hugging Face compatibles con la biblioteca listos para usar, no es necesario implementar ganchos manualmente para traducir APIs Transformer `smdistributed` a capas de transformadores. [Puedes activar el paralelismo tensorial usando el administrador de contexto smdistributed.modelparallel.torch.tensor\$1parallelism () y empaquetando el modelo con [smdistributed.modelparallel.torch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tensor_parallelism). DistributedModel().](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel) No necesita registrar manualmente los enlaces para el paralelismo de los tensores mediante la API `smp.tp_register`.
Es posible acceder a las funciones de traducción `state_dict` entre Hugging Face Transformers y `smdistributed.modelparallel` de la siguiente manera.
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_state_dict_to_hf_gpt2(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_hf_state_dict_to_smdistributed_gpt2(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_state_dict_to_hf_bert(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_hf_state_dict_to_smdistributed_bert(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_state_dict_to_hf_roberta(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_hf_state_dict_to_smdistributed_roberta(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_state_dict_to_hf_gptj(state_dict, max_seq_len=None)`(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.8.0 y versiones posteriores)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.8.0 y versiones posteriores)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.10.0 y versiones posteriores)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.10.0 y versiones posteriores)
**Ejemplo de uso de la característica de traducción GPT-2**
Comience por encapsular el modelo tal y como se muestra en el siguiente código.
```
from transformers import AutoModelForCausalLM
with smp.tensor_parallelism():
model = AutoModelForCausalLM.from_config(hf_gpt2_config)
model = smp.DistributedModel(model)
```
Dado un `state_dict` del objeto `DistributedModel`, puede cargar las ponderaciones en el modelo original de Hugging Face GPT-2 usando la característica `translate_state_dict_to_hf_gpt2` como se muestra en el siguiente código.
```
from smdistributed.modelparallel.torch.nn.huggingface.gpt2 \
import translate_state_dict_to_hf_gpt2
max_seq_len = 1024
# [... code block for training ...]
if smp.rdp_rank() == 0:
state_dict = dist_model.state_dict()
hf_state_dict = translate_state_dict_to_hf_gpt2(state_dict, max_seq_len)
# can now call model.load_state_dict(hf_state_dict) to the original HF model
```
**Ejemplo de uso de la función de traducción Ro BERTa **
Del mismo modo, dado un HuggingFace modelo compatible`state_dict`, puede utilizar la `translate_hf_state_dict_to_smdistributed` función para convertirla a un formato legible`smp.DistributedModel`. Esto puede ser útil en casos de uso de transferencia de aprendizaje, donde un modelo preentrenado se carga en un `smp.DistributedModel` para un ajuste paralelo modelo.
```
from smdistributed.modelparallel.torch.nn.huggingface.roberta \
import translate_state_dict_to_smdistributed
model = AutoModelForMaskedLM.from_config(roberta_config)
model = smp.DistributedModel(model)
pretrained_model = AutoModelForMaskedLM.from_pretrained("roberta-large")
translated_state_dict =
translate_state_dict_to_smdistributed(pretrained_model.state_dict())
# load the translated pretrained weights into the smp.DistributedModel
model.load_state_dict(translated_state_dict)
# start fine-tuning...
```
# Mecanismo de clasificación cuando se utiliza una combinación de paralelismo de canalización y paralelismo de tensores
En esta sección se explica cómo funciona el mecanismo de clasificación del paralelismo de modelos con el paralelismo de tensores. Esto es una extensión de los conceptos [básicos de clasificación](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#ranking-basics) para [Características principales de la biblioteca de paralelismo de SageMaker modelos](model-parallel-core-features.md). Con el paralelismo tensorial, la biblioteca presenta tres tipos de clasificación y grupo de procesos: para el rango paralelo `smp.tp_rank()` tensorial, APIs para el rango paralelo de `smp.pp_rank()` canalización y para `smp.rdp_rank()` el rango paralelo de datos reducidos. Los grupos de proceso de comunicación correspondientes son grupo paralelo tensorial (`TP_GROUP`), grupo paralelo de canalización (`PP_GROUP`) y grupo paralelo de datos reducidos (`RDP_GROUP`). Estos grupos se definen de la siguiente manera:
+ Un *grupo paralelo tensorial* (`TP_GROUP`) es un subconjunto uniformemente divisible del grupo paralelo de datos, sobre el cual tiene lugar la distribución tensorial paralela de los módulos. Cuando el grado de paralelismo de la canalización es 1, `TP_GROUP` es el mismo que el del *grupo paralelo modelo* (`MP_GROUP`).
+ Un *grupo paralelo de canalización* (`PP_GROUP`) es el grupo de procesos sobre los que tiene lugar el paralelismo de canalización. Cuando el grado de paralelismo de tensores es 1, `PP_GROUP` es igual que `MP_GROUP`.
+ Un *grupo paralelo de datos reducidos* (`RDP_GROUP`) es un conjunto de procesos que contienen las mismas particiones de paralelismo de canalización y las mismas particiones paralelas tensoriales, y realizan paralelismo de datos entre sí. Esto se denomina grupo paralelo de datos reducido porque es un subconjunto de todo el grupo de paralelismo de datos, `DP_GROUP`. Para los parámetros del modelo que se distribuyen dentro del `TP_GROUP`, la operación `allreduce` del gradiente se realiza solo para el grupo paralelo de datos reducidos, mientras que para los parámetros que no están distribuidos, el gradiente `allreduce` se produce en todo el grupo `DP_GROUP`.
+ Un grupo paralelo de modelos (`MP_GROUP`) se refiere a un grupo de procesos que almacenan colectivamente todo el modelo. Consiste en la unión de los `PP_GROUP`s de todos los rangos que se encuentran en el `TP_GROUP` del proceso actual. Cuando el grado de paralelismo de tensores es 1, `MP_GROUP` equivale a `PP_GROUP`. También es coherente con la definición existente de `MP_GROUP` de versiones anteriores de `smdistributed`. Tenga en cuenta que el actual `TP_GROUP` es un subconjunto del actual `DP_GROUP` y del actual `MP_GROUP`.
*Para obtener más información sobre el proceso de comunicación APIs en la biblioteca de paralelismo de SageMaker modelos, consulta la [API común](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html#) y la específica [PyTorchen la documentación del SDK de APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) PythonSageMaker .*
![\[Mecanismo de clasificación, distribución de parámetros y AllReduce operaciones asociadas del paralelismo tensorial.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-ranking-mechanism.png)
Por ejemplo, considere los grupos de procesos para un solo nodo con 8 GPUs, donde el grado de paralelismo tensorial es 2, el grado de paralelismo de canalización es 2 y el grado de paralelismo de datos es 4. La parte central superior de la figura anterior muestra un ejemplo de un modelo con 4 capas. Las partes inferior izquierda e inferior derecha de la figura ilustran el modelo de 4 capas distribuido en 4 GPUs utilizando tanto el paralelismo de canalización como el paralelismo tensorial, donde el paralelismo tensorial se usa para las dos capas centrales. Estas dos figuras inferiores son copias simples para ilustrar diferentes líneas de límite de grupo. El modelo particionado se replica para lograr un paralelismo de datos entre 0-3 y 4-7. GPUs La figura inferior izquierda muestra las definiciones de `MP_GROUP`, `PP_GROUP` y `TP_GROUP`. La figura inferior derecha muestra`RDP_GROUP`, `DP_GROUP` y sobre el mismo conjunto de. `WORLD` GPUs Los gradientes de las capas y los sectores de capas que tienen el mismo color están agrupados en `allreduce` para obtener un paralelismo de datos. Por ejemplo, en la primera capa (azul claro) se transmiten las operaciones `allreduce` en `DP_GROUP`, mientras que en el segmento naranja oscuro de la segunda capa solo se transmiten las operaciones `allreduce` de dentro del `RDP_GROUP` de su proceso. Las flechas de color rojo oscuro en negrita representan los tensores con el lote completo `TP_GROUP`.
```
GPU0: pp_rank 0, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 0
GPU1: pp_rank 1, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 1
GPU2: pp_rank 0, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 2
GPU3: pp_rank 1, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 3
GPU4: pp_rank 0, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 0
GPU5: pp_rank 1, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 1
GPU6: pp_rank 0, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 2
GPU7: pp_rank 1, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 3
```
En este ejemplo, el paralelismo de canalización se produce entre los pares de GPU (0,1); (2,3); (4,5) y (6,7). Además, el paralelismo de datos (`allreduce`) tiene lugar en GPUs 0, 2, 4, 6 e independientemente en GPUs 1, 3, 5 y 7. El paralelismo de tensores se produce en subconjuntos de `DP_GROUP`s, en los pares de GPU (0,2); (1,3); (4,6) y (5,7).
Para este tipo de paralelismo híbrido entre canalización y tensor, la matemática para `data_parallel_degree` sigue siendo `data_parallel_degree = number_of_GPUs / pipeline_parallel_degree`. La biblioteca calcula además el grado de paralelismo de datos reducidos a partir de la siguiente relación `reduced_data_parallel_degree * tensor_parallel_degree = data_parallel_degree`.
# Partición del estado del optimizador
La *partición del estado del optimizador* es una técnica útil para ahorrar memoria que parte el estado del optimizador (el conjunto de ponderaciones que describe el estado del optimizador) entre grupos de dispositivos paralelos de datos. Puede utilizar la fragmentación del estado del optimizador siempre que utilice un optimizador con estado (como Adam) o un FP16 optimizador (que almacena ambos parámetros y copias de ellos). FP16 FP32
**nota**
La fragmentación del estado del optimizador está disponible PyTorch en la biblioteca de paralelismo de modelos v1.6.0 y versiones posteriores SageMaker .
## Cómo utilizar la partición de estados del optimizador
Puede activar la *partición del estado del optimizador* estableciendo `"shard_optimizer_state": True` en la configuración de `modelparallel`.
Cuando esta característica está activada, la biblioteca divide el conjunto de parámetros del modelo en función del grado de paralelismo de los datos. Los gradientes correspondientes a la división número `i` se reducen solo en el rango paralelo de datos número `i`. Al final de la primera llamada a una característica del decorador `smp.step`, el optimizador encapsulado con `smp.DistributedOptimizer` redefine sus parámetros para limitarse solo a los parámetros correspondientes a la división del rango paralelo de datos actual. Los parámetros redefinidos se denominan *parámetros virtuales* y comparten el almacenamiento subyacente con los parámetros originales. Durante la primera llamada a `optimizer.step`, los estados del optimizador se crean en función de estos parámetros redefinidos, que están partidos debido a la partición original. Tras la actualización del optimizador, la AllGather operación (como parte de la `optimizer.step` llamada) se ejecuta en los rangos paralelos de datos para lograr estados de parámetros consistentes.
**sugerencia**
La partición del estado del optimizador puede resultar útil cuando el grado de paralelismo de los datos es superior a 1 y el modelo tiene más de mil millones de parámetros.
El grado de paralelismo de los datos se calcula mediante `(processes_per_host * instance_count / pipeline_parallel_degree)` y la característica `smp.dp_size()` gestiona el tamaño en segundo plano.
**Configure un estimador SageMaker PyTorch **
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"shard_optimizer_state": True
}
}
```
**Adapta tu guion de entrenamiento PyTorch **
Consulta Cómo [adaptar tu guion de PyTorch entrenamiento](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism-script) en la sección Paralelismo *tensorial combinado con paralelismo* de canalización. No es necesario realizar ninguna modificación adicional en el script.
# Puntos de control de activación
Los *puntos de control de activación* (o *puntos de control de gradiente*) son una técnica para reducir el uso de memoria al borrar las activaciones de determinadas capas y volver a calcularlas durante una pasada hacia atrás. De hecho, esto cambia el tiempo de cálculo adicional por un menor uso de memoria. Si se comprueba un módulo, al final de una pasada hacia adelante, las entradas y salidas del módulo permanecen en la memoria. Todos los tensores intermedios que hubieran formado parte del cálculo dentro de ese módulo se liberan durante la pasada hacia adelante. Durante la pasada hacia atrás de los módulos con puntos de control, estos tensores vuelven a calcularse. En este punto, las capas situadas más allá de este módulo de puntos de control han terminado su pasada hacia atrás, por lo que el uso máximo de memoria con los puntos de control puede ser menor.
**nota**
Esta función está disponible en la biblioteca de paralelismo de modelos, versión PyTorch 1.6.0 y versiones posteriores SageMaker .
## Cómo utilizar los puntos de control de activación
Con `smdistributed.modelparallel`, puede utilizar los puntos de control de activación en la granularidad de un módulo. En todos los módulos `torch.nn`, excepto `torch.nn.Sequential`, solo puede controlar un árbol de módulos si se encuentra dentro de una partición desde la perspectiva del paralelismo de canalización. En el caso del módulo `torch.nn.Sequential`, cada árbol de módulos del módulo secuencial debe estar completamente dentro de una partición para que los puntos de control de activación funcionen. Cuando utilice la división manual, tenga en cuenta estas restricciones.
Cuando utiliza la [división automatizada de modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-automated-model-splitting), puede encontrar los registros de asignación de particiones que comienzan con `Partition assignments:` en los registros de trabajos de entrenamiento. Si un módulo está dividido en varios rangos (por ejemplo, con un descendiente en un rango y otro descendiente en un rango diferente), la biblioteca ignora el intento de poner puntos de control al módulo y muestra un mensaje de advertencia que indica que el módulo no estará sujeto a puntos de verificación.
**nota**
La biblioteca de paralelismo de SageMaker modelos admite operaciones de superposición y no superposición en combinación con puntos de control. `allreduce`
**nota**
PyTorchSu API de puntos de control nativa no es compatible con. `smdistributed.modelparallel`
**Ejemplo 1:** el siguiente código de ejemplo muestra cómo utilizar los puntos de control de activación cuando se tiene una definición de modelo en el script.
```
import torch.nn as nn
import torch.nn.functional as F
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
# This call of fc1 will be checkpointed
x = checkpoint(self.fc1, x)
x = self.fc2(x)
return F.log_softmax(x, 1)
```
**Ejemplo 2:** el siguiente código de ejemplo muestra cómo utilizar los puntos de control de activación cuando se tiene un modelo secuencial en el script.
```
import torch.nn as nn
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint_sequential
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.seq = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
def forward(self, x):
# This call of self.seq will be checkpointed
x = checkpoint_sequential(self.seq, x)
return F.log_softmax(x, 1)
```
**Ejemplo 3:** El siguiente código de ejemplo muestra cómo utilizar los puntos de control de activación al importar un modelo prediseñado de una biblioteca, como Hugging Face PyTorch Transformers. Tanto si comprueba los módulos secuenciales como si no, haga lo siguiente:
1. Encapsule el modelo con `smp.DistributedModel()`.
1. Defina un objeto para las capas secuenciales.
1. Encapsule el objeto de la capa secuencial con `smp.set_activation_checkpointig()`.
```
import smdistributed.modelparallel.torch as smp
from transformers import AutoModelForCausalLM
smp.init()
model = AutoModelForCausalLM(*args, **kwargs)
model = smp.DistributedModel(model)
# Call set_activation_checkpointing API
transformer_layers = model.module.module.module.transformer.seq_layers
smp.set_activation_checkpointing(
transformer_layers, pack_args_as_tuple=True, strategy='each')
```
# Descarga de activación
Cuando los puntos de control de activación y el paralelismo de canalización están activados y el número de microlotes es superior a uno, la *descarga de activación* es una característica adicional que puede reducir aún más el uso de memoria. La descarga de activación mueve de forma asíncrona las activaciones controladas por puntos de control correspondientes a sus microlotes que no se están ejecutando actualmente en la CPU. Justo antes de que la GPU necesite las activaciones para la pasada hacia atrás del microlote, esta funcionalidad recupera previamente las activaciones descargadas de la CPU.
**nota**
Esta función está disponible PyTorch en la biblioteca de paralelismo de SageMaker modelos v1.6.0 y versiones posteriores.
## Cómo utilizar la descarga de activación
Utilice la descarga de activación para reducir el uso de memoria cuando **el número de microlotes sea superior a 1 y el punto de control de activación esté activado ** (consulte [Puntos de control de activación](model-parallel-extended-features-pytorch-activation-checkpointing.md)). Si no se utiliza el punto de control de activación, la descarga de activación no tiene ningún efecto. Si se utiliza con un solo microlote, no ahorra memoria.
Para utilizar la descarga de activación, establezca `"offload_activations": True` en la configuración `modelparallel`.
La descarga de activación mueve las activaciones puntuales de los módulos `nn.Sequential` a la CPU de forma asíncrona. La transferencia de datos a través del PCIe enlace se superpone con el cálculo de la GPU. La descarga se produce inmediatamente, tan pronto como se calcula el paso hacia adelante de una capa determinada con puntos de control. Las activaciones vuelven a cargarse en la GPU poco antes de que se necesiten para retroceder un microlote específico. La transferencia CPU-GPU también se superpone con la computación.
Para ajustar la prontitud en que se cargan las activaciones en la GPU, puede usar el parámetro de configuración `"activation_loading_horizon"` (el valor predeterminado es 4, `int` debe ser mayor que 0). Un horizonte de carga de activación más grande haría que las activaciones se cargaran de nuevo en la GPU con antelación. Si el horizonte es demasiado amplio, es posible que disminuya el impacto de la descarga de la activación en el ahorro de memoria. Si el horizonte es demasiado pequeño, es posible que las activaciones no se carguen en el tiempo, lo que reduce la cantidad de superposiciones y reduce el rendimiento.
**sugerencia**
La descarga de activación puede resultar útil para modelos grandes con más de cien mil millones de parámetros.
**Configure un estimador SageMaker PyTorch **
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"offload_activations": True,
"activation_loading_horizon": 4 # optional. default is 4.
}
}
```
# FP16 Entrenamiento con paralelismo de modelos
Para la FP16 formación, aplique las siguientes modificaciones al guion y al estimador de formación.
**nota**
Esta función está disponible PyTorch en la biblioteca de paralelismo de SageMaker modelos, versión 1.10.0 y versiones posteriores.
** PyTorch Adapta tu guion de entrenamiento**
1. Encapsule su modelo con el administrador de contexto [smdistributed.modelparallel.torch.model\$1creation()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.model_creation).
```
# fp16_training_script.py
import torch
import smdistributed.modelparallel.torch as smp
with smp.model_creation(
dtype=torch.float16 if args.fp16 else torch.get_default_dtype()
):
model = ...
```
**sugerencia**
Si utiliza el paralelismo de tensores, agregue `tensor_parallelism=smp.tp_size() > 1` al gestor contextual `smp.model_creation`. Agregar esta línea también ayuda a detectar automáticamente si el paralelismo de tensores está activado o no.
```
with smp.model_creation(
... ,
tensor_parallelism=smp.tp_size() > 1
):
model = ...
```
1. Al encapsular el optimizador con `smdistributed.modelparallel.torch.DistributedOptimizer`, establezca el argumento `static_loss_scaling` o `dynamic_loss_scaling`. De forma predeterminada, `static_loss_scaling` se establece en `1.0` y `dynamic_loss_scaling` se establece en `False`. Si establece `dynamic_loss_scale=True`, puede introducir las opciones de escalado dinámico de pérdidas como un diccionario a través del argumento `dynamic_loss_args`. En la mayoría de los casos, le recomendamos utilizar el escalado de pérdidas dinámico con las opciones predeterminadas. [Para obtener más información, opciones y ejemplos de la función encapsuladora del optimizador, consulte smdistributed.modelparallel.torch. DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedoptimizer) API.
El siguiente código es un ejemplo de cómo empaquetar un objeto `Adadelta` optimizador con una escala de pérdida dinámica para el FP16 entrenamiento.
```
optimizer = torch.optim.Adadelta(...)
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={
"scale_window": 1000,
"min_scale": 1,
"delayed_shift": 2
}
)
```
**Configure un estimador SageMaker PyTorch **
Agregue el FP16 parámetro (`"fp16"`) a la configuración de distribución para el paralelismo del modelo al crear un objeto estimador. SageMaker PyTorch Para obtener una lista completa de los parámetros de configuración del paralelismo de modelos, consulte [Parámetros de `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed).
```
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2,
"tensor_parallel_degree": 2,
...,
"fp16": True
}
}
fp16_estimator = PyTorch(
entry_point="fp16_training_script.py", # Specify your train script
...,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": {...}
}
)
fp16_estimator.fit(...)
```
[Cuando se inicia el FP16 entrenamiento, el modelo y el optimizador vienen acompañados de versiones modificadas `smdistributed` de las `FP16_Module` utilidades de Apex, `FP16_Optimizer` respectivamente.](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils) `FP16_Module`convierte el modelo en FP16 dtype y se ocupa de la transferencia hacia adelante. FP16
**sugerencia**
Puede aplicar recorte de gradiente llamando `clip_master_grads` antes de `optimizer.step`.
```
optimizer.clip_master_grads(max_norm) # max_norm(float or int): max norm of the gradients
```
**sugerencia**
Al usar `torch.optim.lr_scheduler` y FP16 entrenar, debes pasar `optimizer.optimizer` al programador LR en lugar del optimizador. Vea el siguiente código de ejemplo:
```
from torch.optim.lr_scheduler import StepLR
scheduler = StepLR(
optimizer.optimizer if smp.state.cfg.fp16 else optimizer,
step_size=1,
gamma=args.gamma
)
```
# Support para FlashAttention
Support for FlashAttention es una función de la biblioteca que solo se aplica al modelo de *transformador distribuido*, que es un modelo de transformador incluido [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel)para el entrenamiento en paralelo con modelos. Esta característica también es compatible con [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
La [FlashAttention](https://github.com/HazyResearch/flash-attention)biblioteca solo admite modelos cuando `attention_head_size` se establece en un valor que es múltiplo de 8 e inferior a 128. Por lo tanto, cuando entrenes un transformador distribuido y te asegures de que FlashAttention funciona correctamente, debes ajustar los parámetros para que el tamaño del cabezal de atención cumpla con los requisitos. Para obtener más información, consulte también [Instalación y características](https://github.com/HazyResearch/flash-attention#installation-and-features) del *FlashAttention GitHubrepositorio*.
Por ejemplo, supongamos que configura un modelo de Transformer con `hidden_width=864` y `num_heads=48`. El tamaño de la cabeza de FlashAttention se calcula como`attention_head_size = hidden_width / num_heads = 864 / 48 = 18`. Para FlashAttention activarlo, debe ajustar el `num_heads` parámetro a`54`, de modo que `attention_head_size = hidden_width / num_heads = 864 / 54 = 16` sea un múltiplo de 8.
# Ejecute un trabajo de formación SageMaker distribuido con Model Paralelism
Aprenda a ejecutar un trabajo de entrenamiento en paralelo con un modelo con su propio script de entrenamiento utilizando el SDK de SageMaker Python con la biblioteca de paralelismo de SageMaker modelos.
Existen tres casos de uso para ejecutar un trabajo de formación. SageMaker
1. Puede utilizar uno de los contenedores de aprendizaje AWS profundo prediseñados para y. TensorFlow PyTorch Le recomendamos esta opción si es la primera vez que utiliza la biblioteca de paralelismo de modelos. Para encontrar un tutorial sobre cómo ejecutar un trabajo de formación en paralelo con SageMaker modelos, consulte los cuadernos de ejemplo de [PyTorch entrenamiento con la biblioteca de paralelismo de modelos de Amazon SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel).
1. Puede ampliar los contenedores prediseñados para gestionar cualquier requisito funcional adicional de su algoritmo o modelo que no sea compatible con la imagen de Docker prediseñada SageMaker . Para ver un ejemplo de cómo ampliar un contenedor prediseñado, consulte [Ampliar una contenedor precompilado](prebuilt-containers-extend.md).
1. [Puedes adaptar tu propio contenedor de Docker para que funcione con la SageMaker IA mediante el kit de herramientas de formación. SageMaker ](https://github.com/aws/sagemaker-training-toolkit) Para ver un ejemplo, consulte [Adaptación de su propio contenedor de entrenamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html).
Para ver las opciones 2 y 3 de la lista anterior, consulte [Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos](model-parallel-sm-sdk.md#model-parallel-customize-container) para obtener información sobre cómo instalar la biblioteca de paralelismo de modelos en un contenedor de Docker ampliado o personalizado.
En todos los casos, debe iniciar su trabajo de formación configurando un `PyTorch` estimador SageMaker `TensorFlow` o un estimador para activar la biblioteca. Para obtener más información, consulte los temas siguientes.
**Topics**
+ [Paso 1: modifique su propio script de entrenamiento utilizando SageMaker la biblioteca paralela de modelos distribuidos](model-parallel-customize-training-script.md)
+ [Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python](model-parallel-sm-sdk.md)
# Paso 1: modifique su propio script de entrenamiento utilizando SageMaker la biblioteca paralela de modelos distribuidos
Utilice esta sección para aprender a personalizar su guion de entrenamiento para utilizar las funciones principales de la biblioteca de paralelismo de modelos de SageMaker IA de Amazon. Para utilizar las funciones y los parámetros de la API específicos de la biblioteca, le recomendamos que utilice esta documentación junto con la [biblioteca de modelos SageMaker paralelos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) de la documentación APIs del SDK de *SageMaker Python*.
Los ejemplos de scripts de entrenamiento proporcionados en estas secciones están simplificados y diseñados para resaltar los cambios necesarios que debe realizar para utilizar la biblioteca. Para ver end-to-end ejemplos de cuadernos ejecutables que muestran cómo utilizar un script TensorFlow o un script de PyTorch entrenamiento con la biblioteca de paralelismo de SageMaker modelos, consulte. [Ejemplos de la biblioteca de paralelismo de modelos Amazon SageMaker AI v2](distributed-model-parallel-v2-examples.md)
**Topics**
+ [Divida el modelo de su guion de entrenamiento mediante la biblioteca de modelos de paralelismo SageMaker](#model-parallel-model-splitting-using-smp-lib)
+ [Modifica un script de entrenamiento TensorFlow](model-parallel-customize-training-script-tf.md)
+ [Modifique un guion PyTorch de entrenamiento](model-parallel-customize-training-script-pt.md)
## Divida el modelo de su guion de entrenamiento mediante la biblioteca de modelos de paralelismo SageMaker
Existen dos formas de modificar el script de entrenamiento para configurar la división del modelo: la división automática o la división manual.
### División automatizada de modelos
*Al utilizar SageMaker la biblioteca de paralelismo de modelos, puede aprovechar la división *automática de modelos, también conocida como partición automática de modelos*.* La biblioteca utiliza un algoritmo de partición que equilibra la memoria, minimiza la comunicación entre dispositivos y optimiza el rendimiento. Puede configurar el algoritmo de partición automatizado para optimizar la velocidad o la memoria.
Alternativamente, puede utilizar la división manual de modelos. Recomendamos la división automática de modelos, a menos que esté muy familiarizado con la arquitectura del modelo y tenga una buena idea de cómo particionar su modelo de manera eficiente.
#### Funcionamiento
La partición automática se produce durante el primer paso de entrenamiento, cuando la función decorada por `smp.step` se llama por primera vez. Durante esta llamada, la biblioteca construye primero una versión del modelo en la RAM de la CPU (para evitar limitaciones de memoria de la GPU) y, a continuación, analiza el gráfico del modelo y toma una decisión de partición. En base a esta decisión, cada partición de modelo se carga en una GPU y solo entonces se ejecuta el primer paso. Debido a estos pasos de análisis y partición, el primer paso de entrenamiento podría llevar más tiempo.
En cualquiera de los dos marcos, la biblioteca gestiona la comunicación entre los dispositivos a través de su propio backend, que está optimizado para la infraestructura. AWS
El diseño de partición automática se adapta a las características del marco y la biblioteca realiza la partición a un nivel de granularidad más natural en cada marco. Por ejemplo TensorFlow, en cada operación específica se puede asignar a un dispositivo diferente, mientras que en PyTorch, la asignación se realiza a nivel de módulo, donde cada módulo consta de múltiples operaciones. En la siguiente sección se revisan los detalles del diseño en cada marco.
##### División automática del modelo con PyTorch
Durante el primer paso de entrenamiento, la biblioteca de paralelismo de modelos ejecuta internamente un paso de trazado destinado a construir el gráfico del modelo y determinar las formas de los tensores y parámetros. Tras este paso de rastreo, la biblioteca construye un árbol, que consiste en el anidado de objetos `nn.Module` del modelo, así como datos adicionales recopilados a partir del rastreo, como la cantidad de `nn.Parameters` almacenados, y tiempo de ejecución para cada `nn.Module`.
A continuación, la biblioteca atraviesa este árbol desde la raíz y ejecuta un algoritmo de partición que asigna a cada `nn.Module` a un dispositivo que equilibra la carga computacional (medida por el tiempo de ejecución del módulo) y el uso de la memoria (medida por el total tamaño y activaciones de `nn.Parameter` totales almacenadas). Si múltiples `nn.Modules` comparten el mismo `nn.Parameter`, estos módulos se colocan en el mismo dispositivo para evitar mantener varias versiones del mismo parámetro. Una vez tomada la decisión de particionar, los módulos y pesos asignados se cargan en sus dispositivos.
Para obtener instrucciones sobre cómo registrar al `smp.step` decorador en su guion de PyTorch formación, consulte. [División automática con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16)
##### División automática de modelos con TensorFlow
La biblioteca de paralelismo de modelos analiza los tamaños de las variables que pueden entrenarse y la estructura del gráfico, y utiliza internamente un algoritmo de partición de gráficos. Este algoritmo presenta una asignación de dispositivos para cada operación, con el objetivo de minimizar la cantidad de comunicación necesaria entre los dispositivos, sujeto a dos restricciones:
+ Equilibrio del número de variables almacenadas en cada dispositivo
+ Equilibrio del número de operaciones ejecutadas en cada dispositivo
Si especifica `speed` en `optimize` (en los parámetros paralelos del modelo en el Python SDK), la biblioteca intenta equilibrar el número de operaciones y objetos `tf.Variable` de cada dispositivo. De lo contrario, intenta equilibrar el tamaño total de `tf.Variables`.
Una vez tomada la decisión de particionar, la biblioteca crea una representación serializada del subgráfico que cada dispositivo necesita ejecutar e importa en cada dispositivo. Durante la partición, la biblioteca coloca operaciones que consumen el mismo `tf.Variable` y operaciones que forman parte de la misma capa de Keras en el mismo dispositivo. También respeta las restricciones de colocación impuestas por. TensorFlow Esto significa que, por ejemplo, si hay dos capas Keras que comparten un `tf.Variable`, todas las operaciones que forman parte de estas capas se colocan en un solo dispositivo.
Para obtener instrucciones sobre cómo inscribir al `smp.step` decorador en su guion de PyTorch formación, consulte. [División automática con TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-23)
##### Comparación del modelo automatizado dividido entre marcos
En TensorFlow, la unidad fundamental de cálculo es a y TensorFlow representa el modelo como un `tf.Operation` grafo acíclico dirigido (DAG) de `tf.Operation` s y, por lo tanto, la biblioteca de paralelismo de modelos divide este DAG para que cada nodo vaya a un dispositivo. Y lo que es más importante, los objetos `tf.Operation` son lo suficientemente ricos con atributos personalizables y son universales en el sentido de que cada modelo está garantizado por un gráfico de dichos objetos.
PyTorch por otro lado, no tiene una noción de operación equivalente que sea lo suficientemente rica y universal. La unidad de cálculo más cercana PyTorch que tiene estas características es una`nn.Module`, que se encuentra en un nivel de granularidad mucho más alto, y es por eso que la biblioteca realiza particiones a este nivel en. PyTorch
### División manual de modelos
Si desea especificar manualmente cómo particionar su modelo entre dispositivos, use el administrador de contexto `smp.partition`. Para obtener instrucciones acerca de cómo configurar el administrador de contexto para la partición manual, consulte las siguientes páginas.
+ [Dividir manualmente con TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-manual)
+ [Dividir manualmente con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16-hvd)
Para usar esta opción después de realizar modificaciones, en el paso 2, tendrás que configurar y definir `auto_partition` a `False` `default_partition` en la clase de estimador del framework del SDK de SageMaker Python. Cualquier operación que no se coloque explícitamente en una partición a través del gestor de contextos de `smp.partition` se ejecuta en el `default_partition`. En este caso, se omite la lógica de división automatizada y cada operación se realiza según su especificación. En función de la estructura gráfica resultante, la biblioteca de paralelismo de modelos crea automáticamente una programación de ejecución canalizada.
# Modifica un script de entrenamiento TensorFlow
En esta sección, aprenderá a modificar los scripts de TensorFlow entrenamiento para configurar la biblioteca de paralelismo del SageMaker modelo para el particionamiento automático y el particionamiento manual. Esta selección de ejemplos incluye también un ejemplo integrado con Horovod para modelos híbridos y paralelismo de datos.
**nota**
Para saber qué TensorFlow versiones son compatibles con la biblioteca, consulte. [Marcos compatibles y Regiones de AWS](distributed-model-parallel-support.md)
Las modificaciones necesarias que debe realizar en el script de entrenamiento para utilizar la biblioteca se enumeran en [División automática con TensorFlow](#model-parallel-customize-training-script-tf-23).
Para obtener información sobre cómo modificar el script de entrenamiento para utilizar el modelo híbrido y el paralelismo de datos con Horovod, consulte [División automática con Horovod para el paralelismo de datos TensorFlow y modelos híbridos](#model-parallel-customize-training-script-tf-2.3).
Si quiere usar particiones manuales, revise también [Dividir manualmente con TensorFlow](#model-parallel-customize-training-script-tf-manual).
Los siguientes temas muestran ejemplos de scripts de entrenamiento que puede usar para configurar la biblioteca de paralelismo SageMaker de modelos para modelos de particionamiento automático y particionamiento manual. TensorFlow
**nota**
La partición automática está habilitada de forma predeterminada. A menos que se especifique lo contrario, los scripts de ejemplo utilizan la partición automática.
**Topics**
+ [División automática con TensorFlow](#model-parallel-customize-training-script-tf-23)
+ [División automática con Horovod para el paralelismo de datos TensorFlow y modelos híbridos](#model-parallel-customize-training-script-tf-2.3)
+ [Dividir manualmente con TensorFlow](#model-parallel-customize-training-script-tf-manual)
+ [Características del marco no compatibles](#model-parallel-tf-unsupported-features)
## División automática con TensorFlow
Se requieren los siguientes cambios en el script de entrenamiento para ejecutar un TensorFlow modelo con SageMaker la biblioteca de paralelismo de modelos:
1. Importe e inicialice la biblioteca con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Definir el modelo de Keras que se hereda de [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html) en lugar de la clase de modelo Keras. Devolver las salidas del modelo desde el método de llamada del objeto `smp.DistributedModel`. Tenga en cuenta que los tensores devueltos del método de llamada se transmitirán a través de dispositivos de paralelismo de modelos, lo que supondrá una sobrecarga de comunicación, por lo que no se debe devolver los tensores que no sean necesarios fuera del método de llamada (como las activaciones intermedias).
1. Establezca `drop_remainder=True` en el método `tf.Dataset.batch()`. Esto sirve para garantizar que el tamaño del lote sea siempre divisible por el número de microlotes.
1. Inserte las operaciones aleatorias en la canalización de datos`smp.dp_rank()`, por ejemplo, `shuffle(ds, seed=smp.dp_rank())` para garantizar la coherencia de las muestras de datos entre las GPUs que se encuentran distintas particiones de modelos.
1. Coloque la lógica hacia adelante y hacia atrás en una función de paso y decórela con `smp.step`.
1. Realice un procesamiento posterior en las salidas de los microlotes mediante los métodos [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) tales como `reduce_mean`. La función [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init) debe tener un valor devuelto que depende de la salida de `smp.DistributedModel`.
1. Si hay algún paso de evaluación, coloque de manera similar la lógica de avance dentro de una función decorada `smp.step` y procese posteriormente las salidas utilizando la [API `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput).
[Para obtener más información sobre la API SageMaker de la biblioteca de paralelismo de modelos de la API, consulte la documentación de la API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
El siguiente script de Python es un ejemplo de un script de entrenamiento después de realizar los cambios.
```
import tensorflow as tf
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return the model output
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
Si ha terminado de preparar el script de entrenamiento, continúe con [Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python](model-parallel-sm-sdk.md). Si desea ejecutar un trabajo de entrenamiento paralelo de datos y modelo híbrido, proceda con la siguiente sección.
## División automática con Horovod para el paralelismo de datos TensorFlow y modelos híbridos
Puede utilizar la biblioteca de paralelismo de SageMaker modelos con Horovod para el paralelismo de datos y modelos híbridos. Para obtener más información sobre cómo la biblioteca divide un modelo para el paralelismo híbrido, consulte [PyTorch TensorFlowParalelismo de canalización (disponible para y)](model-parallel-intro.md#model-parallel-intro-pp).
En este paso, nos centramos en cómo modificar el guion de entrenamiento para adaptar la biblioteca de paralelismo del modelo. SageMaker
Para configurar correctamente su script de entrenamiento para que recoja la configuración de paralelismo híbrido que utilizará en [Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python](model-parallel-sm-sdk.md), utilice las funciones auxiliares de la biblioteca, `smp.dp_rank()` y `smp.mp_rank()`, que detectan automáticamente el rango de paralelismo de datos y el rango de paralelismo de modelos, respectivamente.
Para encontrar todas las primitivas de MPI que admite la biblioteca, consulte [Conceptos básicos de MPI en la documentación](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#mpi-basics) del SDK de SageMaker Python.
Los cambios principales necesarios en el script son:
+ Añadir `hvd.allreduce`
+ Variables de radiodifusión después del primer lote, según lo requerido por Horovod
+ Sembrando las operaciones de and/or fragmentación aleatoria en la canalización de datos con. `smp.dp_rank()`
**nota**
Cuando utilice Horovod, no debe llamar directamente `hvd.init` en su script de entrenamiento. En su lugar, tendrás que `"horovod"` configurarlo `True` en los `modelparallel` parámetros del SDK de SageMaker Python en[Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python](model-parallel-sm-sdk.md). Esto permite que la biblioteca inicialice Horovod internamente en función de las asignaciones de dispositivos de las particiones del modelo. Llamar `hvd.init()` directamente a su script de entrenamiento puede provocar problemas.
**nota**
El uso de la API `hvd.DistributedOptimizer` directamente en el script de entrenamiento puede provocar un rendimiento y una velocidad de entrenamiento deficientes, ya que la API incluye implícitamente la operación `AllReduce` en `smp.step`. Le recomendamos utilizar la biblioteca de paralelismo de modelos con Horovod llamando `hvd.allreduce` directamente después de llamar a `accumulate()` o `reduce_mean()` o en los gradientes devueltos por `smp.step`, como se mostrará en el siguiente ejemplo.
[Para obtener más información sobre la API SageMaker de la biblioteca de paralelismo de modelos de la API, consulta la documentación de la API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import tensorflow as tf
import horovod.tensorflow as hvd
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: Seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return model outputs
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels, first_batch):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
# Horovod: AllReduce the accumulated gradients
gradients = [hvd.allreduce(g.accumulate()) for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# Horovod: Broadcast the variables after first batch
if first_batch:
hvd.broadcast_variables(model.variables, root_rank=0)
hvd.broadcast_variables(optimizer.variables(), root_rank=0)
# smdistributed: Merge predictions across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for batch, (images, labels) in enumerate(train_ds):
loss = train_step(images, labels, tf.constant(batch == 0))
```
## Dividir manualmente con TensorFlow
Uso de gestores de contexto de `smp.partition` para colocar las operaciones en una partición específica. Toda operación no colocada en ningún contexto `smp.partition` se colocará en `default_partition`. [Para obtener más información sobre la API SageMaker de la biblioteca de paralelismo de modelos de esta, consulta la documentación de la API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import tensorflow as tf
# smdistributed: Import TF2.x API.
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches.
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API.
class MyModel(smp.DistributedModel):
def __init__(self):
# define layers
def call(self, x):
with smp.partition(0):
x = self.layer0(x)
with smp.partition(1):
return self.layer1(x)
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
## Características del marco no compatibles
La biblioteca no admite las siguientes TensorFlow funciones:
+ Actualmente `tf.GradientTape()` no es compatible. Puede usar `Optimizer.get_gradients()` o `Optimizer.compute_gradients()` en lugar de gradiente informáticos.
+ Actualmente, la API `tf.train.Checkpoint.restore()` no es compatible. Para los puntos de control, utilice `smp.CheckpointManager` en su lugar, que proporciona la misma API y funcionalidad. Tenga en cuenta que las restauraciones del punto de control con `smp.CheckpointManager` deben realizarse después del primer paso.
# Modifique un guion PyTorch de entrenamiento
En esta sección, aprenderá a modificar los scripts de PyTorch entrenamiento para configurar la biblioteca de paralelismo del SageMaker modelo para el particionamiento automático y el particionamiento manual.
**nota**
Para saber qué PyTorch versiones son compatibles con la biblioteca, consulte. [Marcos compatibles y Regiones de AWS](distributed-model-parallel-support.md)
**sugerencia**
Para ver ejemplos de end-to-end cuadernos que muestran cómo utilizar un guion de PyTorch entrenamiento con la biblioteca de SageMaker modelos de paralelismo, consulte. [Ejemplos de la biblioteca de paralelismo de modelos Amazon SageMaker AI v1](distributed-model-parallel-examples.md)
Tenga en cuenta que la partición automática está habilitada de forma predeterminada. A menos que se especifique lo contrario, los siguientes scripts utilizan la partición automática.
**Topics**
+ [División automática con PyTorch](#model-parallel-customize-training-script-pt-16)
+ [Dividir manualmente con PyTorch](#model-parallel-customize-training-script-pt-16-hvd)
+ [Consideraciones](#model-parallel-pt-considerations)
+ [Características del marco no compatibles](#model-parallel-pt-unsupported-features)
## División automática con PyTorch
Se requieren los siguientes cambios en el guion de entrenamiento para ejecutar un guion de PyTorch entrenamiento con SageMaker la biblioteca de paralelismo de modelos:
1. Importe e inicialice la biblioteca con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Encapsule el modelo con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel). Tenga en cuenta que los tensores devueltos por el método `forward` del objeto subyacente se transmitirán a través de dispositivos paralelos al modelo, lo que generará una sobrecarga de comunicación, por lo que no se deben devolver los tensores que no sean necesarios fuera del método de llamada (como activaciones intermedias).
**nota**
Para el FP16 entrenamiento, debe usar el administrador de contexto [smdistributed.modelparallel.torch.model\$1creation](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) () para empaquetar el modelo. Para obtener más información, consulte [FP16 Entrenamiento con paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md).
1. Encapsule el optimizador con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer).
**nota**
Para FP16 el entrenamiento, debe configurar el escalado de pérdidas estático o dinámico. Para obtener más información, consulte [FP16 Entrenamiento con paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md).
1. Usa el objeto `DistributedModel` devuelto en lugar de un modelo de usuario.
1. Coloque la lógica hacia adelante y hacia atrás en una función de paso y decórela con [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Restrinja cada proceso a su propio dispositivo mediante `torch.cuda.set_device(smp.local_rank())`.
1. Mueva los tensores de entrada a la GPU mediante la API `.to()` antes de la llamada `smp.step` (véase el ejemplo a continuación).
1. Sustituya `torch.Tensor.backward` y `torch.autograd.backward` por `DistributedModel.backward`.
1. Realice un procesamiento posterior en las salidas de los microlotes mediante los métodos [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) como `reduce_mean`.
1. Si hay algún paso de evaluación, coloque de manera similar la lógica de avance dentro de la función decorada `smp.step` y procese posteriormente las salidas utilizando la [API `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput).
1. Establezca `drop_last=True` en `DataLoader`. Alternativamente, omita manualmente un lote en el ciclo de entrenamiento si el tamaño del lote no es divisible por el número de microlotes.
[Para obtener más información sobre la API SageMaker de la biblioteca de paralelismo de modelos de la API, consulte la documentación de la API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
# define layers
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Dividir manualmente con PyTorch
Utilice los gestores de contexto de [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer) para colocar módulos en dispositivos específicos. Todo módulo no colocado en ningún contexto `smp.partition` se colocará en `default_partition`. El `default_partition` debe proporcionarse si `auto_partition` está establecido en `False`. Los módulos que se crean dentro de un determinado contexto `smp.partition` se colocan en la partición correspondiente.
[Para obtener más información sobre la API SageMaker de la biblioteca de paralelismo de modelos de esta, consulta la documentación de la API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
with smp.partition(0):
# define child modules on device 0
with smp.partition(1):
# define child modules on device 1
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Consideraciones
Al configurar un script de PyTorch entrenamiento mediante SageMaker la biblioteca de paralelismo de modelos, debe tener en cuenta lo siguiente:
+ Si utiliza una técnica de optimización que se basa en normas de degradado globales, por ejemplo, una norma de degradado de todo el modelo, como algunas variantes del optimizador LAMB o el recorte de degradado global, debe recopilar todas las normas en las particiones del modelo para que sean correctas. Puede utilizar los tipos de datos básicos de comunicación de la biblioteca para hacerlo.
+ Todos los argumentos `torch.Tensor` a los métodos de reenvío del modelo `nn.Modules` deben utilizarse en el cálculo de la salida del módulo. En otras palabras, la biblioteca no admite ese caso en el que hay un argumento `torch.Tensor` a un módulo del que no depende la salida del módulo.
+ El argumento a la llamada `smp.DistributedModel.backward()` debe depender de todas las salidas del modelo. En otras palabras, no puede haber una salida de la llamada `smp.DistributedModel.forward` que no se utilice en el cálculo del tensor que se introduce en la llamada `smp.DistributedModel.backward`.
+ Si hay llamadas `torch.cuda.synchronize()` en su código, es posible que tenga que llamar `torch.cuda.set_device(smp.local_rank())` inmediatamente antes de la llamada de sincronización. De lo contrario, se podrían crear contextos CUDA innecesarios en el dispositivo 0, que consumirá memoria innecesariamente.
+ Desde que la biblioteca coloca `nn.Modules` en distintos dispositivos, los módulos del modelo no deben depender de ningún estado global modificado en `smp.step`. Cualquier estado que permanezca fijo durante todo el entrenamiento o que se modifique fuera de `smp.step` de forma visible para todos los procesos, está permitido.
+ No es necesario mover el modelo a la GPU (por ejemplo, usando `model.to(device)`) al utilizar la biblioteca. Si intenta mover el modelo a la GPU antes de particionar el modelo (antes de la primera llamada `smp.step`), se ignora la llamada de movimiento. La biblioteca mueve automáticamente la parte del modelo asignada a un rango a su GPU. Una vez que comience el entrenamiento con la biblioteca, no mueva el modelo a la CPU y lo utilice, ya que no tendrá parámetros correctos para los módulos no asignados a la partición que tiene el proceso. Si quieres volver a entrenar un modelo o usarlo para realizar inferencias sin la biblioteca después de haberlo entrenado con la biblioteca de paralelismo de modelos, la forma recomendada es guardar el modelo completo con nuestra API de puntos de control y volver a cargarlo en un módulo normal. PyTorch
+ Si tiene una lista de módulos de modo que la salida de uno alimenta a otro, reemplazar esa lista por `nn.Sequential` puede mejorar significativamente el rendimiento.
+ La actualización de peso (`optimizer.step()`) tiene que ocurrir fuera de `smp.step`porque es cuando se hace todo el paso hacia atrás y los gradientes están listos. Cuando se utiliza un modelo híbrido con paralelismo de modelos y datos, en este punto también se garantiza que los gradientes finalizarán. AllReduce
+ Cuando utilice la biblioteca en combinación con el paralelismo de datos, asegúrese de que el número de lotes en todos los rangos paralelos de datos sea el mismo para que AllReduce no se quede esperando a que un rango no participe en el paso.
+ Si lanza un trabajo de entrenamiento utilizando un tipo de instancia ml.p4d (como ml.p4d.24xlarge), debe establecer la variable del cargador de datos `num_workers=0`. Por ejemplo, puede definir su `DataLoader` de la siguiente manera:
```
dataloader = torch.utils.data.DataLoader(
data,
batch_size=batch_size,
num_workers=0,
pin_memory=True,
drop_last=True,
shuffle=shuffle,
)
```
+ Las entradas para `smp.step` deben ser las entradas de modelo generadas por `DataLoader`. Esto se debe a que `smp.step` divide internamente los tensores de entrada a lo largo de la dimensión del lote y los canaliza. Esto significa que pasar `DataLoader` a la `smp.step` para generar las entradas del modelo en el interior no funciona.
Por ejemplo, si define un `DataLoader` de la siguiente manera:
```
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
```
Debe acceder a las entradas del modelo generadas por `train_loader` y pasarlos a una función decorada por `smp.step`. No pase `train_loader` directamente a la función `smp.step`.
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
...
_, loss_mb = train_step(model, data, target)
...
@smp.step
def train_step(model, data, target):
...
return output, loss
```
+ Los tensores de entrada a `smp.step` debe, moverse al dispositivo actual mediante la API `.to()`, que debe tener lugar después de la llamada `torch.cuda.set_device(local_rank())`.
Por ejemplo, puede utilizar la función `train` de la siguiente manera. Esta función añade `data` y `target` al dispositivo actual utilizando la API `.to()` antes de usar esos tensores de entrada para llamar `train_step`.
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
```
Los tensores de entrada para esta función decorado por `smp.set` se ha movido al dispositivo actual en la función `train` anterior. El modelo *no* debe moverse al dispositivo actual. La biblioteca mueve automáticamente la parte del modelo asignada a un rango a su GPU.
```
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
```
## Características del marco no compatibles
La biblioteca de paralelismo de modelos de la biblioteca de paralelismo de modelos no admite las siguientes PyTorch funciones: SageMaker
+ Si utiliza el paralelismo de datos con el [PyTorch DDP](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) nativo, la biblioteca no admite el módulo [https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)contenedor. La biblioteca gestiona internamente la integración con el PyTorch DDP, incluida la transmisión de parámetros y el gradiente. AllReduce Cuando se utiliza la biblioteca, los búferes de módulo solo se transmiten una vez al comienzo del entrenamiento. Si el modelo tiene búferes de módulo que deben sincronizarse entre los grupos paralelos de datos en cada paso, puede hacerlo a través de la API `torch.distributed`, utilizando el grupo de procesos que se puede obtener mediante `smp.get_dp_process_group()`.
+ Para un entrenamiento de precisión mixta, el módulo `apex.amp` no es compatible. La forma recomendada de utilizar la biblioteca con precisión mixta automática es utilizar `torch.cuda.amp`, con la excepción de utilizar `smp.amp.GradScaler` en lugar de la aplicación en antorcha.
+ `torch.jit.ScriptModules` o `ScriptFunctions` no son compatibles con `smp.DistributedModel`.
+ `apex` : `FusedLayerNorm`, `FusedAdam`, `FusedLAMB` y `FusedNovoGrad` de `apex` no son compatibles. Puede utilizar las implementaciones de la biblioteca de principio a fin `smp.optimizers` y `smp.nn` APIs en su lugar.
# Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python
El SDK de SageMaker Python admite el entrenamiento gestionado de modelos con marcos de aprendizaje automático como TensorFlow y PyTorch. Para iniciar un trabajo de formación con uno de estos marcos, debe definir un SageMaker [TensorFlow estimador, un estimador o](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) un SageMaker [PyTorch estimador](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) SageMaker genérico para utilizar el guion de entrenamiento modificado y la [configuración](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator) de paralelismo del modelo.
**Topics**
+ [PyTorch Uso de los estimadores y SageMaker TensorFlow](#model-parallel-using-sagemaker-pysdk)
+ [Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos](#model-parallel-customize-container)
+ [Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker](#model-parallel-bring-your-own-container)
## PyTorch Uso de los estimadores y SageMaker TensorFlow
Las clases TensorFlow y PyTorch estimador contienen el `distribution` parámetro, que puede utilizar para especificar los parámetros de configuración para utilizar marcos de entrenamiento distribuidos. La biblioteca paralela de SageMaker modelos usa MPI internamente para datos híbridos y paralelismo de modelos, por lo que debe usar la opción MPI con la biblioteca.
La siguiente plantilla de un PyTorch estimador TensorFlow or muestra cómo configurar el `distribution` parámetro para utilizar la biblioteca SageMaker paralela de modelos con MPI.
------
#### [ Using the SageMaker TensorFlow estimator ]
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
smp_options = {
"enabled":True, # Required
"parameters": {
"partitions": 2, # Required
"microbatches": 4,
"placement_strategy": "spread",
"pipeline": "interleaved",
"optimize": "speed",
"horovod": True, # Use this for hybrid model and data parallelism
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8, # Required
# "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}
smd_mp_estimator = TensorFlow(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='2.6.3',
py_version='py38',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
------
#### [ Using the SageMaker PyTorch estimator ]
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": { # Required
"pipeline_parallel_degree": 2, # Required
"microbatches": 4,
"placement_strategy": "spread",
"pipeline": "interleaved",
"optimize": "speed",
"ddp": True,
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8, # Required
# "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py38',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
------
Para habilitar la biblioteca, es necesario pasar los diccionarios de configuración a `"mpi"` las claves `"smdistributed"` y a través del `distribution` argumento de los constructores del SageMaker estimador.
**Parámetros de configuración para el paralelismo del modelo SageMaker**
+ Para la clave `"smdistributed"`, pase un diccionario con la clave `"modelparallel"` y los siguientes diccionarios internos.
**nota**
No se admite el uso de `"modelparallel"` y `"dataparallel"` en un trabajo de entrenamiento.
+ `"enabled"`: obligatorio. Para habilitar el paralelismo de modelos, establezca `"enabled": True`.
+ `"parameters"`: obligatorio. Especifique un conjunto de parámetros para SageMaker el paralelismo del modelo.
+ Para obtener una lista completa de los parámetros comunes, consulte [Parámetros de `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) la *documentación del SDK de SageMaker Python*.
Para ver TensorFlow, consulte [Parámetros TensorFlow específicos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters).
Para ver PyTorch, consulte [PyTorchParámetros específicos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters).
+ `"pipeline_parallel_degree"` (o `"partitions"` en `smdistributed-modelparallel
Para ampliar un contenedor prediseñado y usar SageMaker la biblioteca de paralelismo de modelos, debe usar una de las imágenes de AWS Deep Learning Containers (DLC) disponibles para o. PyTorch TensorFlow La biblioteca de paralelismo de SageMaker modelos se incluye en las imágenes del DLC TensorFlow (2.3.0 y versiones posteriores) y (1.6.0 y versiones posteriores) con PyTorch CUDA (). `cuxyz` Para obtener una lista completa de imágenes de DLC, consulte Imágenes de [Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) en el * GitHub repositorio de AWS Deep Learning Containers*.
**sugerencia**
Le recomendamos que utilice la imagen que contiene la última versión de la biblioteca de paralelismo de SageMaker modelos TensorFlow o PyTorch para acceder a la mayoría de las up-to-date versiones de la misma.
Por ejemplo, su Dockerfile debe contener una declaración `FROM` similar a la siguiente:
```
# Use the SageMaker DLC image URI for TensorFlow or PyTorch
FROM aws-dlc-account-id.dkr.ecr.aws-region.amazonaws.com/framework-training:{framework-version-tag}
# Add your dependencies here
RUN ...
ENV PATH="/opt/ml/code:${PATH}"
# this environment variable is used by the SageMaker AI container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
```
Además, al definir un TensorFlow estimador PyTorch o, debe especificarlo para su guion de `entry_point` entrenamiento. Debe ser el mismo camino identificado con `ENV SAGEMAKER_SUBMIT_DIRECTORY` en su Dockerfile.
**sugerencia**
Debe enviar este contenedor de Docker a Amazon Elastic Container Registry (Amazon ECR) y usar el URI de la imagen (`image_uri`) para definir un estimador para el entrenamiento. SageMaker Para obtener más información, consulte [Ampliar una contenedor precompilado](prebuilt-containers-extend.md).
Cuando termine de alojar el contenedor de Docker y de recuperar el URI de la imagen del contenedor, cree un objeto estimador de la siguiente manera. SageMaker `PyTorch` En este ejemplo se supone que ya ha definido `smp_options` y `mpi_options`.
```
smd_mp_estimator = Estimator(
entry_point="your_training_script.py",
role=sagemaker.get_execution_role(),
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
image_uri='your_aws_account_id.dkr.ecr.region.amazonaws.com/name:tag'
instance_count=1,
distribution={
"smdistributed": smp_options,
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker
Para crear su propio contenedor Docker para el entrenamiento y usar la biblioteca paralela de SageMaker modelos, debe incluir las dependencias correctas y los archivos binarios de las bibliotecas SageMaker paralelas distribuidas en su Dockerfile. Esta sección proporciona el conjunto mínimo de bloques de código que debe incluir para preparar adecuadamente un entorno de SageMaker entrenamiento y la biblioteca paralela de modelos en su propio contenedor de Docker.
**nota**
Esta opción de Docker personalizada con la biblioteca paralela del SageMaker modelo como binario solo está disponible para PyTorch.
**Para crear un Dockerfile con el kit de herramientas de SageMaker entrenamiento y la biblioteca paralela de modelos**
1. Comience con una de las [imágenes base de NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda).
```
FROM
```
**sugerencia**
Las imágenes oficiales del AWS Deep Learning Container (DLC) se crean a partir de las imágenes base de [NVIDIA](https://hub.docker.com/r/nvidia/cuda) CUDA. Te recomendamos que consultes los [archivos Dockerfiles oficiales de AWS Deep Learning Container PyTorch para](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) saber qué versiones de las bibliotecas necesitas instalar y cómo configurarlas. Los Dockerfiles oficiales están completos, sometidos a pruebas comparativas y gestionados por los equipos de servicio y de Deep Learning Container. SageMaker En el enlace proporcionado, elige la PyTorch versión que utilizas, elige la carpeta CUDA (`cuxyz`) y elige el Dockerfile que termina en o. `.gpu` `.sagemaker.gpu`
1. Para establecer un entorno de entrenamiento distribuido, debe instalar software para dispositivos de comunicación y red, como Elastic Fabric Adapter (EFA), [NVIDIA Collective Communications Library (NCCL](https://developer.nvidia.com/nccl) y [Open MPI](https://www.open-mpi.org/). Según las versiones PyTorch y CUDA que elija, debe instalar versiones compatibles de las bibliotecas.
**importante**
Dado que la biblioteca paralela de SageMaker modelos requiere la biblioteca paralela de SageMaker datos en los pasos siguientes, le recomendamos encarecidamente que siga las instrucciones que aparecen en [Cree su propio contenedor Docker con la biblioteca paralela de datos distribuidos de SageMaker IA](data-parallel-bring-your-own-container.md) para configurar correctamente un entorno de SageMaker formación para la formación distribuida.
Para obtener más información sobre cómo configurar EFA con NCCL y Open MPI, consulte [Introducción a EFA y MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) e [Introducción a EFA y NCCL](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html).
1. Añada los siguientes argumentos para especificar cuáles URLs son los paquetes de formación SageMaker distribuidos PyTorch. La biblioteca paralela de SageMaker modelos requiere que la biblioteca paralela de SageMaker datos utilice el acceso remoto directo a memoria (RDMA) entre nodos.
```
ARG SMD_MODEL_PARALLEL_URL=https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.10.0/build-artifacts/2022-02-21-19-26/smdistributed_modelparallel-1.7.0-cp38-cp38-linux_x86_64.whl
ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.10.2/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
```
1. Instale las dependencias que requiera la biblioteca paralela de SageMaker modelos.
1. Instale la biblioteca [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview).
```
ARG METIS=metis-5.1.0
RUN rm /etc/apt/sources.list.d/* \
&& wget -nv http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/${METIS}.tar.gz \
&& gunzip -f ${METIS}.tar.gz \
&& tar -xvf ${METIS}.tar \
&& cd ${METIS} \
&& apt-get update \
&& make config shared=1 \
&& make install \
&& cd .. \
&& rm -rf ${METIS}.tar* \
&& rm -rf ${METIS} \
&& rm -rf /var/lib/apt/lists/* \
&& apt-get clean
```
1. Instale la [biblioteca RAPIDS Memory Manager](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Esto requiere la versión [CMake](https://cmake.org/)3.14 o una versión posterior.
```
ARG RMM_VERSION=0.15.0
RUN wget -nv https://github.com/rapidsai/rmm/archive/v${RMM_VERSION}.tar.gz \
&& tar -xvf v${RMM_VERSION}.tar.gz \
&& cd rmm-${RMM_VERSION} \
&& INSTALL_PREFIX=/usr/local ./build.sh librmm \
&& cd .. \
&& rm -rf v${RMM_VERSION}.tar* \
&& rm -rf rmm-${RMM_VERSION}
```
1. Instale la biblioteca paralela de SageMaker modelos.
```
RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL}
```
1. Instale la biblioteca paralela de SageMaker datos.
```
RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
```
1. Instale el [kit de herramientas sagemaker-training](https://github.com/aws/sagemaker-training-toolkit). El kit de herramientas contiene la funcionalidad común necesaria para crear un contenedor compatible con la plataforma de SageMaker entrenamiento y el SDK de SageMaker Python.
```
RUN pip install sagemaker-training
```
1. Cuando termine de crear el Dockerfile, consulte [Adaptación de su propio contenedor de entrenamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) para aprender a crear el contenedor de Docker y alojarlo en Amazon ECR.
**sugerencia**
Para obtener más información general sobre cómo crear un Dockerfile personalizado para el entrenamiento en SageMaker IA, consulte [Use sus propios](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html) algoritmos de entrenamiento.
# Puntos de control y ajuste de un modelo con paralelismo de modelos
La biblioteca de paralelismo de SageMaker modelos proporciona puntos de control APIs para guardar el estado del modelo y el estado del optimizador divididos por las distintas estrategias de paralelismo del modelo, y para cargar los puntos de control para el entrenamiento continuo desde donde se desee reiniciar el entrenamiento y realizar ajustes. APIs También admiten opciones para guardar los estados del modelo y del optimizador de forma parcial o total.
**Topics**
+ [Punto de control de un modelo distribuido](#distributed-model-parallel-checkpoint)
+ [Ajustar con precisión un modelo distribuido](#distributed-model-parallel-fine-tuning)
## Punto de control de un modelo distribuido
Elija uno de los siguientes temas en función del marco existente PyTorch TensorFlow y de la versión de la biblioteca de paralelismo de SageMaker modelos que utilice.
**Topics**
+ [Verificación de un PyTorch modelo distribuido (para la biblioteca de paralelismo de SageMaker modelos v1.10.0 y versiones posteriores)](#model-parallel-extended-features-pytorch-checkpoint)
+ [Controlar un PyTorch modelo distribuido (para la biblioteca de paralelismo de modelos entre las versiones 1.6.0 y SageMaker 1.9.0)](#model-parallel-extended-features-pytorch-saving-loading-checkpoints)
+ [Verificación de un modelo distribuido TensorFlow](#distributed-model-parallel-checkpoint-tensorflow)
### Verificación de un PyTorch modelo distribuido (para la biblioteca de paralelismo de SageMaker modelos v1.10.0 y versiones posteriores)
La biblioteca de paralelismo de SageMaker modelos proporciona puntos de control APIs para guardar y cargar puntos de control totales o parciales del estado del modelo distribuido y su estado del optimizador.
**nota**
Se recomienda utilizar este método de puntos de control si se utiliza la biblioteca de paralelismo de modelos PyTorch v1.10.0 o posterior SageMaker .
**Puntos de control parciales**
Para guardar los puntos de control de un modelo entrenado con paralelismo de modelos, usa la API [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint) con la opción de puntos de control parcial establecida en true (`partial=True`). Esto guarda cada partición del modelo de forma individual. Además del modelo y el estado del optimizador, también puede guardar cualquier dato personalizado adicional mediante el argumento `user_content`. El modelo de puntos de control, el optimizador y el contenido del usuario se guardan como archivos independientes. La llamada a la API `save_checkpoint` crea carpetas de puntos de control con la siguiente estructura.
```
- path
- ${tag}_partial (folder for partial checkpoints)
- model_rankinfo.pt
- optimizer_rankinfo.pt
- fp16_states_rankinfo.pt
- user_content.pt
- $tag (checkpoint file for full checkpoints)
- user_content_$tag (user_content file for full checkpoints)
- newest (a file that indicates the newest checkpoint)
```
Para reanudar el entrenamiento a partir de puntos de control parciales, utilice la API [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint) con `partial=True` y especifique el directorio de puntos de control y la etiqueta utilizada mientras guarda los puntos de control parciales. Tenga en cuenta que la carga real de los pesos del modelo ocurre después de la partición del modelo, durante la primera ejecución de la función de paso de entrenamiento decorada por `smdistributed.modelparallel.torch.step`.
Al guardar un punto de control parcial, la biblioteca también guarda la decisión de partición del modelo como archivos con la extensión del archivo `.pt`. Por el contrario, al reanudar desde el punto de control parcial, la biblioteca carga los archivos de decisión de partición juntos. Una vez que la decisión de partición esté cargada, no podrá cambiar la partición.
El siguiente fragmento de código muestra cómo establecer el punto de control en un script de entrenamiento. APIs PyTorch
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=True,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=True
)
```
**Puntos de control completos**
Para guardar el artefacto del modelo final con fines de inferencia, utilice la API `smdistributed.modelparallel.torch.save_checkpoint` con `partial=False`, que combina las particiones del modelo para crear un único artefacto modelo. Tenga en cuenta que esto no combina los estados del optimizador.
Para iniciar el entrenamiento con pesos específicos, con un punto de control del modelo completo, puede usar la API `smdistributed.modelparallel.torch.resume_from_checkpoint` con `partial=False`. Tenga en cuenta que esto no carga los estados del optimizador.
**nota**
Con el paralelismo de tensores, en general, el `state_dict` debe traducirse entre la implementación del modelo original y la implementación de `DistributedModel`. Si lo desea, puede proporcionar la función de traducción `state_dict` como argumento para el `smdistributed.modelparallel.torch.resume_from_checkpoint`. Sin embargo, para [Modelos compatibles listos para usar](model-parallel-extended-features-pytorch-hugging-face.md#model-parallel-extended-features-pytorch-hugging-face-out-of-the-box), la biblioteca se encarga de esta traducción automáticamente.
El código siguiente muestra un ejemplo de cómo utilizar el punto de control APIs para controlar completamente un PyTorch modelo entrenado con paralelismo de modelos.
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=False,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=False
)
```
### Controlar un PyTorch modelo distribuido (para la biblioteca de paralelismo de modelos entre las versiones 1.6.0 y SageMaker 1.9.0)
La biblioteca de SageMaker modelos de paralelismo proporciona funciones de Python para guardar puntos de control parciales o completos para trabajos de entrenamiento con paralelismo tensorial. El siguiente procedimiento muestra cómo usar [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save) and [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load) para guardar y cargar un punto de control cuando usa el paralelismo de tensores.
**nota**
Se recomienda utilizar este método de puntos de control si se utiliza PyTorch, y la biblioteca de paralelismo de modelos entre las versiones 1.6.0 y [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md) 1.9.0. SageMaker
1. Prepare un objeto modelo y encapsularlo con la función envolvente de la biblioteca `smp.DistributedModel()`.
```
model = MyModel(...)
model = smp.DistributedModel(model)
```
1. Prepare un optimizador para el modelo. Un conjunto de parámetros de modelo es un argumento iterable que requieren las funciones del optimizador. Para preparar un conjunto de parámetros del modelo, debe procesar `model.parameters()` la asignación de parámetros únicos a cada modelo individual. IDs
Si hay parámetros duplicados IDs en el iterable parámetro del modelo, se produce un error al cargar el estado del optimizador con puntos de control. Para crear un iterable de parámetros de modelo únicos IDs para su optimizador, consulte lo siguiente:
```
unique_params = []
unique_params_set = set()
for p in model.parameters():
if p not in unique_params_set:
unique_params.append(p)
unique_params_set.add(p)
del unique_params_set
optimizer = MyOpt(unique_params, ...)
```
1. Encapsule el optimizador utilizando la función de envoltura de la biblioteca `smp.DistributedOptimizer()`.
```
optimizer = smp.DistributedOptimizer(optimizer)
```
1. Guarde el modelo y el estado del optimizador mediante [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save). En función de cómo quiera guardar los puntos de control, seleccione una de las dos opciones siguientes:
+ **Opción 1:** guarde un modelo parcial en cada `mp_rank` para un solo`MP_GROUP`.
```
model_dict = model.local_state_dict() # save a partial model
opt_dict = optimizer.local_state_dict() # save a partial optimizer state
# Save the dictionaries at rdp_rank 0 as a checkpoint
if smp.rdp_rank() == 0:
smp.save(
{"model_state_dict": model_dict, "optimizer_state_dict": opt_dict},
f"/checkpoint.pt",
partial=True,
)
```
Con el paralelismo de tensores, la biblioteca guarda los archivos marcados con el siguiente formato: `checkpoint.pt_{pp_rank}_{tp_rank}`.
**nota**
Con el paralelismo de tensores, asegúrese de configurar la instrucción if como `if smp.rdp_rank() == 0` en lugar de `if smp.dp_rank() == 0`. Cuando el estado del optimizador está dividido con paralelismo de tensores, todos los rangos paralelos de datos reducidos deben guardar su propia partición del estado del optimizador. El uso de una declaración *if* incorrecta para los puntos de control podría provocar un estancamiento del trabajo de entrenamiento. *Para obtener más información sobre el uso `if smp.dp_rank() == 0` sin paralelismo tensorial, consulta la [Instrucción general para guardar y cargar en la documentación del SDK](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) de PythonSageMaker .*
+ **Opción 2:** guarde el modelo completo.
```
if smp.rdp_rank() == 0:
model_dict = model.state_dict(gather_to_rank0=True) # save the full model
if smp.rank() == 0:
smp.save(
{"model_state_dict": model_dict},
"/checkpoint.pt",
partial=False,
)
```
**nota**
Tenga en cuenta lo siguiente para el control completo:
Si establece `gather_to_rank0=True`, todos los rangos excepto `0` devuelven diccionarios vacíos.
Para un control completo, solo puede controlar el modelo. Actualmente no se admite el control completo de los estados del optimizador.
El modelo completo solo necesita guardarse en `smp.rank() == 0`.
1. Cargar los puntos de control mediante [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load). En función de cómo haya seleccionado en el paso anterior, seleccione una de las dos opciones siguientes:
+ **Opción 1:** cargue los puntos de control parciales.
```
checkpoint = smp.load("/checkpoint.pt", partial=True)
model.load_state_dict(checkpoint["model_state_dict"], same_partition_load=False)
optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
```
Puede establecer `same_partition_load=True` en `model.load_state_dict()` para una carga más rápida, si sabe que la partición no cambiará.
+ **Opción 2:** carga los puntos de control completos.
```
if smp.rdp_rank() == 0:
checkpoint = smp.load("/checkpoint.pt", partial=False)
model.load_state_dict(checkpoint["model_state_dict"])
```
La condición `if smp.rdp_rank() == 0` no es necesaria, pero puede ayudar a evitar la carga redundante entre diferentes `MP_GROUP`s. Actualmente, el dictado de estado del optimizador de puntos de control completo no es compatible con el paralelismo de tensores.
### Verificación de un modelo distribuido TensorFlow
Para guardar un TensorFlow modelo mientras se entrena con el paralelismo de modelos, utilice las siguientes funciones que proporciona la biblioteca de paralelismo de modelos. SageMaker
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model)
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager)
## Ajustar con precisión un modelo distribuido
El ajuste preciso debe configurarse en su script de entrenamiento. El siguiente fragmento de código muestra un ejemplo de estructura de un guion de entrenamiento que utiliza la clase [AutoModelForCausalLM](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM) de Hugging Face Transformers con modificaciones para registrar `smdistributed.model.parallel.torch` los módulos y ajustes para su ajuste.
**nota**
Para ajustar con precisión un transformador distribuido (incluido un modelo de Transformer`smp.DistributedModel()`) con la función [smp.delayed\$1param\$1initialization activada, es necesario configurar](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) el trabajo de ajuste preciso con un sistema de archivos compatible con Lustre. FSx En los casos en los que desee ajustar un modelo a gran escala con la opción de inicialización diferida de los parámetros, debe configurar un sistema de archivos para Lustre. FSx
```
import argparse
from transformers import AutoModelForCausalLM
import smdistributed.modelparallel
import smdistributed.modelparallel.torch as smp
def parse_args():
parser = argparse.ArgumentParser()
# set an arg group for model
model_grp = parser.add_argument_group(
title="model", description="arguments to describe model configuration"
)
... # set up numerous args to parse from the configuration dictionary to the script for training
# add arg for activating fine-tuning
model_grp.add_argument(
"--fine_tune",
type=int,
default=0,
help="Fine-tune model from checkpoint or pretrained model",
)
def main():
"""Main function to train GPT."""
args = parse_args()
... # parse numerous args
if args.fine_tune > 0 and args.delayed_param > 0 and smp.rank() == 0:
pretrained_model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
model_state_dict = pretrained_model.state_dict()
path = os.path.join(args.model_dir, "fullmodel.pt")
torch.save(model_state_dict, path)
# create a Transformer model and wrap by smp.model_creation()
# with options to configure model parallelism parameters offered by SageMaker AI
with smp.model_creation(
tensor_parallelism=smp.tp_size() > 1 or args.use_distributed_transformer > 0,
zero_init=args.use_distributed_transformer == 0,
dtype=dtype,
distribute_embedding=args.sharded_data_parallel_degree > 1 and smp.tp_size() > 1,
use_alibi=args.alibi > 0,
attention_in_fp32=args.attention_in_fp32 > 0,
fp32_residual_addition=args.residual_addition_in_fp32 > 0,
query_key_layer_scaling=args.query_key_layer_scaling > 0 and args.bf16 < 1,
fused_softmax=args.fused_softmax > 0,
fused_dropout=args.fused_dropout > 0,
fused_bias_gelu=args.fused_bias_gelu > 0,
flash_attention=args.flash_attention > 0,
):
if args.fine_tune > 0 and args.delayed_param == 0:
model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
else:
model = AutoModelForCausalLM.from_config(model_config)
# wrap the model by smp.DistributedModel() to apply SageMaker model parallelism
model = smp.DistributedModel(
model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation
)
# wrap the optimizer by smp.DistributedOptimizer() to apply SageMaker model parallelism
optimizer= ... # define an optimizer
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
)
# for fine-tuning, use smp.resume_from_checkpoint() to load a pre-trained model
if args.fine_tune > 0 and args.delayed_param > 0:
smp.resume_from_checkpoint(args.model_dir, tag="fullmodel.pt", partial=False)
```
*Para ver un ejemplo completo de guiones de entrenamiento y cuadernos de Jupyter, consulte los ejemplos de la [GPT-2](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel/gpt2) en el repositorio de ejemplos de IA. PyTorch SageMaker GitHub*
# Ejemplos de la biblioteca de paralelismo de modelos Amazon SageMaker AI v1
En esta página encontrará una lista de blogs y cuadernos de Jupyter que presentan ejemplos prácticos de la implementación de la biblioteca de paralelismo de SageMaker modelos (SMP), versión 1, para realizar trabajos de formación distribuidos sobre IA. SageMaker
## Blogs y casos prácticos
En los siguientes blogs se analizan casos prácticos sobre el uso de SMP v1.
+ [Nuevas mejoras de rendimiento en la biblioteca de paralelismo de modelos de Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/), *AWS Machine Learning Blog* (16 de diciembre de 2022)
+ [Entrene modelos gigantescos con escalado casi lineal mediante el paralelismo de datos fragmentados en Amazon AI SageMaker ,](https://aws.amazon.com/blogs/machine-learning/train-gigantic-models-with-near-linear-scaling-using-sharded-data-parallelism-on-amazon-sagemaker/) Machine *AWS Learning Blog (31* de octubre de 2022)
## Cuadernos de ejemplo
[En el repositorio de ejemplos de IA se proporcionan cuadernos de ejemplo. SageMaker GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/training/distributed_training/) Para descargar los ejemplos, ejecute el siguiente comando para clonar el repositorio e ir a `training/distributed_training/pytorch/model_parallel`.
**nota**
Clona y ejecuta los cuadernos de ejemplo en el siguiente SageMaker AI ML. IDEs
[SageMaker JupyterLab](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-jl.html)(disponible en [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creado después de diciembre de 2023)
[SageMaker Editor de código](https://docs.aws.amazon.com/sagemaker/latest/dg/code-editor.html) (disponible en [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creado después de diciembre de 2023)
[Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) (disponible como aplicación en [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) creado después de diciembre de 2023)
[SageMaker Instancias de cuadernos](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html)
```
git clone https://github.com/aws/amazon-sagemaker-examples.git
cd amazon-sagemaker-examples/training/distributed_training/pytorch/model_parallel
```
**Ejemplos de cuadernos SMP v1 para PyTorch**
+ [Entrene el GPT-2 con un escalado casi lineal utilizando la técnica de paralelismo de datos fragmentados de la biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-train-gpt-sharded-data-parallel.ipynb)
+ [Ajuste el GPT-2 con un escalado casi lineal mediante la técnica de paralelismo de datos fragmentados de la biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-fine-tune-gpt-sharded-data-parallel.ipynb)
+ [Entrene el GPT-NeoX-20B con un escalado casi lineal mediante la técnica de paralelismo de datos fragmentados de la biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-neox/smp-train-gpt-neox-sharded-data-parallel.ipynb)
+ [Entrene el GPT-J 6B con las técnicas de paralelismo de datos fragmentados y paralelismo tensorial de la biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-j/smp-train-gptj-sharded-data-parallel-tp.ipynb)
+ [Entrene el FLAN-T5 con un escalado casi lineal utilizando la técnica de paralelismo de datos fragmentados de la biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/flan-t5/smp-train-t5-sharded-data-parallel.ipynb)
+ [Entrene a Falcon con un escalado casi lineal utilizando la técnica de paralelismo de datos fragmentados de la biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/falcon/smp-train-falcon-sharded-data-parallel.ipynb)
**Ejemplos de cuadernos SMP v1 para TensorFlow**
+ [CNN con la TensorFlow versión 2.3.1 y la biblioteca de modelos de SageMaker paralelismo](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/model_parallel/mnist/tensorflow_smmodelparallel_mnist.html)
+ [HuggingFace con la biblioteca de paralelismo de modelos TensorFlow distribuidos Training on AI SageMaker ](https://github.com/huggingface/notebooks/blob/master/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb)
# SageMaker Mejores prácticas de paralelismo de modelos distribuidos
Utilice las siguientes pautas cuando ejecute un trabajo de entrenamiento distribuido con la biblioteca paralela de SageMaker modelos.
## Establecer la configuración correcta para un modelo determinado
Al escalar un modelo, le recomendamos que revise la siguiente lista en orden. Cada elemento de la lista analiza la ventaja de utilizar las técnicas de la biblioteca junto con las compensaciones que podrían surgir.
**sugerencia**
Si un modelo puede encajar bien utilizando un subconjunto de las funciones de la biblioteca, agregar más paralelismo de modelos o funciones de ahorro de memoria no suele mejorar el rendimiento.
**Uso de tipos de instancias de GPU grandes**
+ En el ámbito del paralelismo de modelos, lo mejor es utilizar instancias potentes con grandes memorias de GPU para gestionar la sobrecarga que suponen las operaciones de paralelismo de modelos, como la partición de modelos en varios. GPUs Recomendamos utilizar las instancias `ml.p4d` o `ml.p3dn` para entrenar modelos de aprendizaje profundo grandes. Estas instancias también están equipadas con Elastic Fabric Adapter (EFA), que proporciona un mayor ancho de banda de red y permite un entrenamiento a gran escala con paralelismo de modelos.
**Estado del optimizador de fragmentos**
+ El impacto del estado del optimizador de fragmentos depende del número de rangos del paralelismo de datos. Normalmente, un mayor grado de paralelismo de datos (proporcional al tamaño del nodo informático) puede mejorar la eficiencia del uso de la memoria.
Cuando quiera reducir el tamaño de un clúster, asegúrese de comprobar la configuración de fragmentación de estado del optimizador. Por ejemplo, un modelo DL grande con fragmentación del estado del optimizador que cabe en un clúster de procesamiento con 16 GPUs (por ejemplo, dos instancias P4d o P4de) puede que no siempre quepa en un nodo con 8 GPUs (por ejemplo, una sola instancia P4d o P4de). Esto se debe a que la memoria combinada de 8 GPUs es inferior a la memoria combinada de 16 GPUs, y la memoria requerida por GPU para fragmentar más de 8 también GPUs es mayor que la memoria por GPU para fragmentar en el escenario de 16 GPU. Como resultado, es posible que el aumento de los requisitos de memoria no quepa en un clúster más pequeño.
Para obtener más información, consulte [Partición del estado del optimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md).
**Puntos de control de activación**
+ La eficiencia de la memoria se puede mejorar mediante el control de activación de un grupo de módulos. Cuanto más agrupe los módulos, más eficiente será el uso de la memoria. Al seleccionar módulos secuenciales de puntos de control para capas, el argumento `strategy` de la función `smp.set_activation_checkpointing` agrupa las capas para marcar puntos de control. Por ejemplo, agrupar dos o más capas para hacer puntos de control es más eficiente en la memoria que el punto de control de una capa a la vez, y esto controla un tiempo de cálculo adicional para reducir el uso de la memoria.
Para obtener más información, consulte [Puntos de control de activación](model-parallel-extended-features-pytorch-activation-checkpointing.md).
**Paralelismo de tensores**
+ El grado de paralelismo tensorial debe ser una potencia de dos (2, 4, 8,..., 2 n), donde el grado máximo debe ser igual al número de por nodo. GPUs Por ejemplo, si usa un nodo con 8 GPUs, los números posibles para el grado de paralelismo del tensor son 2, 4 y 8. No recomendamos números arbitrarios (como 3, 5, 6 y 7) para el grado de paralelismo de tensores. Cuando utiliza varios nodos, la configuración incorrecta del grado de paralelismo de tensores podría provocar la ejecución del paralelismo de tensores en los nodos; esto añade una sobrecarga significativa de la comunicación de las activaciones en los nodos y puede resultar costosa computacionalmente.
Para obtener más información, consulte [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
**Paralelismo de canalización entre nodos**
+ Puede ejecutar paralelismo de canalización tanto en un solo nodo como en varios nodos. Cuando utiliza el paralelismo de canalización en combinación con el paralelismo de tensores, le recomendamos ejecutar paralelismo de canalización en varios nodos y mantener el paralelismo de tensores dentro de nodos individuales.
+ El paralelismo de canalización viene con los tres mandos siguientes: `microbatches`, `active_microbatches` y `prescaled_batch`.
+ Cuando utiliza paralelismo de tensores con paralelismo de canalización, le recomendamos activar `prescaled_batch` de modo que se pueda aumentar el tamaño del lote por grupo de paralelismo de modelos para una canalización eficiente. Al activar `prescaled_batch`, el tamaño de lote establecido en el script de entrenamiento pasa a ser `tp_size` veces el tamaño del lote establecido para cada rango sin `prescaled_batch`.
+ Aumentar el número de `microbatches` ayuda a lograr una canalización eficiente y un mejor rendimiento. Tenga en cuenta que el tamaño efectivo del microlote es el tamaño del lote dividido por el número de microlotes. Si aumenta el número de microlotes manteniendo constante el tamaño del lote, cada microlote procesa menos muestras.
+ El número de `active_microbatches` es el número máximo de microlotes que están en proceso simultáneamente durante la canalización. Para cada microlote activo en proceso, sus activaciones y degradados ocupan memoria de la GPU. Por lo tanto, un aumento de `active_microbatches` ocupa más memoria de la GPU.
+ Si la memoria de la GPU y la GPU están infrautilizadas, aumente`active_microbatches` para una mejor paralelización durante la canalización.
+ Para obtener más información sobre cómo utilizar el paralelismo de tensores con paralelismo de canalización, consulte [Paralelismo tensorial combinado con paralelismo de canalización](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism).
+ Para encontrar descripciones de los parámetros antes mencionados, consulte [Parámetros de `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed) en la *documentación del SDK de SageMaker Python*.
**Descarga de activaciones a la CPU**
+ Asegúrese de que se utilice en combinación con el punto de control de activación y el paralelismo de canalización. Para garantizar que la descarga y la precarga se produzcan en segundo plano, especifique un valor superior a 1 para el parámetro microlotes.
+ Al descargar activaciones, es posible que pueda aumentar `active_microbatches` y, a veces, coincide con el número total de microlotes. Esto depende de qué módulos estén marcados y de cómo se divide el modelo.
Para obtener más información, consulte [Descarga de activación](model-parallel-extended-features-pytorch-activation-offloading.md).
### Configuraciones de referencia
El equipo de formación en paralelismo de SageMaker modelos proporciona los siguientes puntos de referencia basados en experimentos con el modelo GPT-2, cuya longitud de secuencia es de 512 y un tamaño de vocabulario de 50 000.
| El número de parámetros de modelos | Tipo de instancia | Paralelismo de canalización | Paralelismo de tensores | Partición de estado del optimizador | Puntos de control de activación | Lote preescalado | BatchSize |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 50 mil millones | 16 ml.p4d.24xlarge | 1 | 4 | True | Cada capa de transformador | True | batch\$1size=40 |
| 30 mil millones | 16 ml.p4d.24xlarge | 1 | 8 | True | Cada capa de transformador | True | batch\$1size=32 |
| 60 mil millones | 32 ml.p4d.24xlarge | 2 | 8 | True | Cada capa de transformador | True | batch\$1size=56, microbatches=4, active\$1microbatches=2 |
Puede extrapolar de las configuraciones anteriores para estimar el uso de la memoria de la GPU para la configuración del modelo. Por ejemplo, si aumenta la longitud de la secuencia de un modelo de 10 mil millones de parámetros o aumenta el tamaño del modelo a 20 mil millones, es posible que desee reducir primero el tamaño del lote. Si el modelo sigue sin encajar, intente aumentar el grado de paralelismo de tensores.
## Modificación del script de entrenamiento
+ Antes de utilizar las funciones de la biblioteca paralela de SageMaker modelos en su guion de entrenamiento, revíselas[Consejos y dificultades de configuración de la biblioteca de paralelismo de modelos SageMaker distribuidos](model-parallel-customize-tips-pitfalls.md).
+ Para iniciar un trabajo de entrenamiento más rápido, usa el [modo local de SageMaker IA](https://sagemaker.readthedocs.io/en/v2.199.0/overview.html?highlight=local%20mode#local-mode). Esto le ayuda a ejecutar rápidamente un trabajo de formación de forma local en una instancia de SageMaker bloc de notas. Según la escala de la instancia de aprendizaje automático en la que se ejecute la instancia de su SageMaker notebook, es posible que necesite ajustar el tamaño del modelo cambiando las configuraciones del modelo, como el ancho oculto, el número de capas de transformadores y los cabezales de atención. Valide si el modelo reducido funciona bien en la instancia de cuaderno antes de utilizar un clúster grande para entrenar el modelo completo.
## Supervisión y registro de un trabajo de formación mediante SageMaker AI Console y Amazon CloudWatch
Para monitorear las métricas a nivel del sistema, como la utilización de la memoria de la CPU, la utilización de la memoria de la GPU y la utilización de la GPU, utilice la visualización proporcionada a través de la consola de [SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. En el panel de navegación situado a la izquierda, seleccione **Entrenamiento**.
1. Seleccione **Trabajos de entrenamiento**.
1. En el panel principal, seleccione el nombre del trabajo de entrenamiento para el que quiera ver más detalles.
1. Examine el panel principal y busque la sección **Monitor** para ver la visualización automatizada.
1. Para ver los registros de trabajos de entrenamiento, seleccione **Ver registros** en la sección **Monitor**. Puede acceder a los registros de trabajos de formación distribuidos del trabajo de formación en. CloudWatch Si inició el entrenamiento distribuido de varios nodos, debería ver varias secuencias de registro con etiquetas en el formato de **algo-n-1234567890**. El flujo de registro **algo-1** realiza un seguimiento de los registros de entrenamiento desde el nodo principal (0.º).
Para obtener más información, consulte [Amazon CloudWatch Metrics para supervisar y analizar los trabajos de formación](training-metrics.md).
## Permisos
Para ejecutar un trabajo de SageMaker formación con un paralelismo de modelos o con los [cuadernos de ejemplos de formación SageMaker distribuidos](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/index.html), asegúrese de tener los permisos correctos en su función de IAM, como los siguientes:
+ [Para usarlo en Lustre, añadaFSx . [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess)](https://aws.amazon.com/fsx/)
+ Para utilizar Amazon S3 como canal de datos, agregue [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess).
+ Para utilizar Docker, cree su propio contenedor y enviarlo a Amazon ECR, agregue [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess).
+ Para tener acceso completo y utilizar todo el conjunto de funciones de SageMaker IA, añada [https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess).
# Consejos y dificultades de configuración de la biblioteca de paralelismo de modelos SageMaker distribuidos
Revise los siguientes consejos y dificultades antes de utilizar la biblioteca de paralelismo de modelos de Amazon SageMaker AI. Esta lista incluye sugerencias que se aplican en todos los marcos. Para obtener consejos PyTorch específicos, consulte TensorFlow [Modifica un script de entrenamiento TensorFlow](model-parallel-customize-training-script-tf.md) y, respectivamente. [Modifique un guion PyTorch de entrenamiento](model-parallel-customize-training-script-pt.md)
## Tamaño del lote y número de microlotes
+ La biblioteca es más eficiente cuando aumenta el tamaño del lote. En los casos de uso en los que el modelo cabe dentro de un solo dispositivo, pero solo se puede entrenar con un tamaño de lote pequeño, el tamaño del lote puede y debe aumentarse después de integrar la biblioteca. El paralelismo de modelos ahorra memoria para modelos grandes, lo que le permite entrenar utilizando tamaños de lote que antes no cabían en la memoria.
+ Elegir varios microlotes que sean demasiado pequeños o demasiado grandes puede reducir el rendimiento. La biblioteca ejecuta cada microlote secuencialmente en cada dispositivo, por lo que el tamaño del microlote (tamaño del lote dividido por el número de microlotes) debe ser lo suficientemente grande como para utilizar completamente cada GPU. Al mismo tiempo, la eficiencia de la canalización aumenta con el número de microlotes, por lo que es importante lograr el equilibrio correcto. Normalmente, un buen punto de partida consiste en probar 2 o 4 microlotes, aumentar el tamaño de los lotes hasta el límite de memoria y, a continuación, experimentar con grandes tamaños de lote y números de microlotes. A medida que aumenta el número de microlotes, los tamaños de lotes más grandes podrían ser factibles si se utiliza una canalización intercalada.
+ El tamaño del lote debe ser siempre divisible por el número de microlotes. Tenga en cuenta que, dependiendo del tamaño del conjunto de datos, a veces el último lote de cada época puede ser de menor tamaño que el resto, y este lote más pequeño también debe ser divisible por el número de microlotes. Si no es así, puede configurar `drop_remainder=True` la `tf.Dataset.batch()` llamada (entrada TensorFlow) o configurar la `drop_last=True` entrada `DataLoader` (entrada PyTorch) para que no se utilice este último lote pequeño. Si utiliza una API diferente para la canalización de datos, es posible que deba omitir manualmente el último lote siempre que no sea divisible por el número de microlotes.
## Partición manual
+ Si utiliza la partición manual, tenga en cuenta los parámetros que consumen varias operaciones y módulos del modelo, como la tabla de incrustación en arquitecturas de transformadores. Los módulos que comparten el mismo parámetro deben colocarse en el mismo dispositivo para que sean correctos. Cuando se utiliza la partición automática, la biblioteca aplica automáticamente esta restricción.
## Preparación de datos
+ Si el modelo toma varias entradas, asegúrese de inicializar las operaciones aleatorias de su canalización de datos (por ejemplo, mezclar) con `smp.dp_rank()`. Si el conjunto de datos se está fragmentando determinísticamente en dispositivos de paralelismo de datos, asegúrese de que el fragmento esté indexado por `smp.dp_rank()`. De este modo se asegurará de que el orden de los datos que se ven en todos los rangos que forman una partición de modelo sea coherente.
## Devolver tensores desde `smp.DistributedModel`
+ Cualquier tensor devuelto por la función `smp.DistributedModel.call` (for TensorFlow) o `smp.DistributedModel.forward` (for PyTorch) se transmite a todos los demás rangos, desde el rango que calculó ese tensor en particular. Como resultado, no debe devolverse cualquier tensor que no sea necesario fuera de los métodos de llamada y reenvío (activaciones intermedias, por ejemplo), ya que esto provoca una comunicación innecesaria y sobrecarga de memoria y perjudica el rendimiento.
## El decorador `@smp.step`
+ Si una función decorada por `smp.step` tiene un argumento tensor que no tiene una dimensión por lotes, el nombre del argumento debe proporcionarse en la lista `non_split_inputs` al llamar`smp.step`. Esto evita que la biblioteca intente dividir el tensor en microlotes. Para obtener más información, consulte [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html) en la documentación de las API.
## Retraso de la inicialización de parámetros
En el caso de modelos muy grandes con más de 100 000 millones de parámetros, la inicialización del peso a través de la memoria de la CPU puede provocar un error. out-of-memory Para evitar esto, la biblioteca ofrece el gestor de contexto de `smp.delay_param_initialization`. Esto retrasa la asignación física de los parámetros hasta que se mueven a la GPU durante la primera ejecución de una función decorada por `smp.step`. Esto evita el uso innecesario de memoria de la CPU durante la inicialización del entrenamiento. Utilice el gestor de contexto cuando cree un objeto modelo como se muestra en el siguiente código.
```
with smp.delay_param_initialization(enabled=True):
model = MyModel()
```
## Paralelismo tensorial para PyTorch
+ Si está utilizando un valor de inicialización para obtener resultados deterministas, establezca el valor de inicialización basándose en `smp.dp_rank()` (por ejemplo, `torch.manual_seed(42 + smp.dp_rank())`). Si no lo hace, diferentes particiones de un `nn.Parameter` se inicializan de la misma manera, lo que afecta a la convergencia.
+ SageMakerLa biblioteca de paralelismo de modelos utiliza NCCL para implementar los colectivos necesarios para la distribución de los módulos. Especialmente en los modelos más pequeños, si se programan demasiadas llamadas NCCL en la GPU al mismo tiempo, el uso de memoria podría aumentar debido al espacio adicional utilizado por NCCL. Para contrarrestar esto, `smp` limita las llamadas de NCCL de modo que el número de operaciones de NCCL en curso en un momento dado sea inferior o igual a un límite determinado. El límite predeterminado es 8, pero se puede ajustar mediante la variable de entorno `SMP_NCCL_THROTTLE_LIMIT`. Si observa más uso de memoria del que espera mientras utiliza el paralelismo de tensores, puede intentar reducir este límite. Sin embargo, elegir un límite demasiado pequeño podría provocar una pérdida de rendimiento. Para deshabilitar la limitación por completo, puede configurar `SMP_NCCL_THROTTLE_LIMIT=-1`.
+ La siguiente identidad, que se mantiene cuando el grado de paralelismo tensor es 1, no se mantiene cuando el grado de paralelismo tensor es superior a 1: `smp.mp_size() * smp.dp_size() == smp.size()`. Esto se debe a que el grupo paralelo de tensores forma parte del grupo paralelismo modelo y del grupo de paralelismo de datos. Si tu código tiene referencias existentes a `mp_rank`, `mp_size`, `MP_GROUP`, etc., y si desea trabajar solo con el grupo paralelo de canalización, es posible que tenga que reemplazar las referencias por `smp.pp_size()`. Las siguientes identidades son siempre ciertas:
+ `smp.mp_size() * smp.rdp_size() == smp.size()`
+ `smp.pp_size() * smp.dp_size() == smp.size()`
+ `smp.pp_size() * smp.tp_size() * smp.rdp_size() == smp.size()`
+ Dado que el encapsulador `smp.DistributedModel` modifica los parámetros del modelo cuando el paralelismo de tensores está habilitado, el optimizador debe crearse después de llamar a `smp.DistributedModel`, con los parámetros distribuidos. Por ejemplo, lo siguiente no funciona:
```
## WRONG
model = MyModel()
optimizer = SomeOptimizer(model.parameters())
model = smp.DistributedModel(model) # optimizer now has outdated parameters!
```
En su lugar, el optimizador debe crearse con los parámetros del `smp.DistributedModel`de la siguiente manera:
```
## CORRECT
model = smp.DistributedModel(MyModel())
optimizer = SomeOptimizer(model.optimizers())
```
+ Cuando un módulo se sustituye por su contraparte distribuida a través del paralelismo de tensores, el módulo distribuido no hereda sus pesos del módulo original e inicializa nuevos pesos. Esto significa que, por ejemplo, si es necesario inicializar las ponderaciones en una llamada concreta (por ejemplo, a través de una llamada `load_state_dict`), esto debe suceder después de la llamada `smp.DistributedModel`, una vez que tenga lugar la distribución del módulo.
+ Al acceder directamente a los parámetros de los módulos distribuidos, tenga en cuenta que el peso no tiene la misma forma que el módulo original. Por ejemplo,
```
with smp.tensor_parallelism():
linear = nn.Linear(60, 60)
# will pass
assert tuple(linear.weight.shape) == (60, 60)
distributed_linear = smp.DistributedModel(linear)
# will fail. the number of input channels will have been divided by smp.tp_size()
assert tuple(distributed_linear.module.weight.shape) == (60, 60)
```
+ Se recomienda encarecidamente usar `torch.utils.data.distributed.DistributedSampler` para el paralelismo de tensores. Esto garantiza que cada clasificación paralela de datos reciba el mismo número de muestras de datos, lo que evita los bloqueos que podrían resultar de diferentes `dp_rank` está tomando un número diferente de pasos.
+ Si utiliza la `join` API PyTorch de la `DistributedDataParallel` clase para gestionar casos en los que diferentes rangos paralelos de datos tienen diferentes números de lotes, aún debe asegurarse de que los rangos que están en el mismo nivel `TP_GROUP` tengan el mismo número de lotes; de lo contrario, los colectivos de comunicación utilizados en la ejecución distribuida de los módulos podrían bloquearse. Rangos que están en diferentes `TP_GROUP`s pueden tener diferentes números de lotes, siempre que se utilice la API `join`.
+ Si desea controlar el modelo y utilizar el paralelismo de tensores, tenga en cuenta lo siguiente:
+ Para evitar el estancamiento y las condiciones de carrera mientras se guardan y cargan modelos cuando utiliza el paralelismo de tensores, asegúrese de llamar a las funciones adecuadas desde los siguientes estados de modelo y optimizador dentro de un rango de paralelismo de datos reducido.
+ Si está haciendo la transición de un script de paralelismo de canalización existente y habilitando el tensor de paralelismo para el script, asegúrese de modificar cualquier bloque `if smp.dp_rank() == 0` utilizado para guardar y cargar con bloques `if smp.rdp_rank() == 0`. De lo contrario, podría hacer que tu trabajo de entrenamiento se detenga.
Para obtener más información sobre el punto de control de un modelo con paralelismo de tensores, consulte [Punto de control de un modelo distribuido](distributed-model-parallel-checkpointing-and-finetuning.md#distributed-model-parallel-checkpoint).
# Solución de problemas de paralelismo de modelos
Si se produce un error, puede utilizar la siguiente lista para intentar solucionar los problemas del trabajo de entrenamiento. Si el problema persiste, póngase en contacto con [Soporte de AWS](https://aws.amazon.com/premiumsupport).
**Topics**
+ [Consideraciones sobre el uso del SageMaker depurador con la biblioteca de paralelismo de SageMaker modelos](#distributed-ts-model-parallel-debugger)
+ [Guardar puntos de control](#distributed-ts-model-parallel-checkpoints)
+ [Convergencia mediante modelos paralelos y TensorFlow](#distributed-ts-model-parallel-tf-convergence)
+ [Estancamiento o bloqueo de trabajos de entrenamiento distribuido](#distributed-ts-model-parallel-training-issues)
+ [Recibir un error de la NCCL para un trabajo de formación PyTorch](#distributed-ts-model-parallel-nccl-error)
+ [Recibir `RecursionError` un trabajo PyTorch de formación](#distributed-ts-model-parallel-super-forward-not-supported)
## Consideraciones sobre el uso del SageMaker depurador con la biblioteca de paralelismo de SageMaker modelos
SageMaker El depurador no está disponible para la biblioteca de paralelismo de modelos. SageMaker El depurador está activado de forma predeterminada para todos los trabajos SageMaker TensorFlow y para los de PyTorch entrenamiento, y es posible que aparezca un error parecido al siguiente:
```
FileNotFoundError: [Errno 2] No such file or directory: '/opt/ml/checkpoints/metadata.json.sagemaker-uploading
```
Para solucionar este problema, deshabilite el depurador pasando `debugger_hook_config=False`al crear un marco `estimator` como se muestra en el siguiente ejemplo.
```
bucket=sagemaker.Session().default_bucket()
base_job_name="sagemaker-checkpoint-test"
checkpoint_in_bucket="checkpoints"
# The S3 URI to store the checkpoints
checkpoint_s3_bucket="s3://{}/{}/{}".format(bucket, base_job_name, checkpoint_in_bucket)
estimator = TensorFlow(
...
distribution={"smdistributed": {"modelparallel": { "enabled": True }}},
checkpoint_s3_uri=checkpoint_s3_bucket,
checkpoint_local_path="/opt/ml/checkpoints",
debugger_hook_config=False
)
```
## Guardar puntos de control
Es posible que te encuentres con el siguiente error al guardar los puntos de control de un modelo grande en la SageMaker IA:
```
InternalServerError: We encountered an internal error. Please try again
```
Esto podría deberse a una limitación de la SageMaker IA al cargar el punto de control local en Amazon S3 durante el entrenamiento. Para deshabilitar los puntos de control en la SageMaker IA, utilice el siguiente ejemplo para cargar los puntos de control de forma explícita.
Si te encuentras con el error anterior, no lo utilices `checkpoint_s3_uri` con la SageMaker `estimator` llamada. Al guardar puntos de control para modelos más grandes, recomendamos guardar los puntos de control en un directorio personalizado y pasar los mismos a la función auxiliar (como el argumento `local_path`).
```
import os
def aws_s3_sync(source, destination):
"""aws s3 sync in quiet mode and time profile"""
import time, subprocess
cmd = ["aws", "s3", "sync", "--quiet", source, destination]
print(f"Syncing files from {source} to {destination}")
start_time = time.time()
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.wait()
end_time = time.time()
print("Time Taken to Sync: ", (end_time-start_time))
return
def sync_local_checkpoints_to_s3(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from local path to s3 """
import boto3
#check if local path exists
if not os.path.exists(local_path):
raise RuntimeError("Provided local path {local_path} does not exist. Please check")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(local_path, s3_uri)
return
def sync_s3_checkpoints_to_local(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from s3 to local path """
import boto3
#try to create local path if it does not exist
if not os.path.exists(local_path):
print(f"Provided local path {local_path} does not exist. Creating...")
try:
os.makedirs(local_path)
except Exception as e:
raise RuntimeError(f"Failed to create {local_path}")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(s3_uri, local_path)
return
```
Uso de funciones auxiliares:
```
#base_s3_uri - user input s3 uri or save to model directory (default)
#curr_host - to save checkpoints of current host
#iteration - current step/epoch during which checkpoint is saved
# save checkpoints on every node using local_rank
if smp.local_rank() == 0:
base_s3_uri = os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))
curr_host = os.environ['SM_CURRENT_HOST']
full_s3_uri = f'{base_s3_uri}/checkpoints/{curr_host}/{iteration}'
sync_local_checkpoints_to_s3(local_path=checkpoint_dir, s3_uri=full_s3_uri)
```
## Convergencia mediante modelos paralelos y TensorFlow
Cuando se utiliza el entrenamiento multinodo de SageMaker IA con TensorFlow la biblioteca de paralelismo de modelos, es posible que la pérdida no converja como se esperaba, ya que el orden de los archivos de entrada del entrenamiento puede ser diferente en cada nodo. Esto puede provocar que distintos rangos del mismo grupo de paralelismo de modelos funcionen en diferentes archivos de entrada, lo que provoca incoherencias. Para evitarlo, asegúrate de que los archivos de entrada estén ordenados del mismo modo en todos los rangos antes de convertirlos en conjuntos de datos. TensorFlow Una forma de lograrlo es ordenar los nombres de los archivos de entrada en el script de entrenamiento.
## Estancamiento o bloqueo de trabajos de entrenamiento distribuido
Si su trabajo de entrenamiento tiene problemas de estancamiento, falla o no responde, lee los siguientes elementos de solución de problemas para identificar cuál es la causa del problema. Si necesita más ayuda, póngase en contacto con el equipo de formación SageMaker distribuida a través de [AWS Support](https://aws.amazon.com/premiumsupport).
+ Si ve **un trabajo de entrenamiento distribuido que se detiene en la etapa de inicialización de la NCCL**, tenga en cuenta lo siguiente:
+ Si utiliza una de las instancias habilitadas para EFA (instancias `ml.p4d` o `ml.p3dn`) con una VPC personalizada y su subred, asegúrese de que el grupo de seguridad utilizado tenga conexiones entrantes y salientes para todos los puertos desde y hacia el mismo SG. Por lo general, también necesita conexiones salientes a cualquier IP como regla independiente (para acceso a Internet). Para obtener instrucciones sobre cómo agregar reglas entrantes y salientes para la comunicación EPT, consulte [SageMaker La IA distribuyó el trabajo de formación y se paralizó durante la inicialización](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-efa-sg).
+ Si ve un **trabajo de entrenamiento distribuido a la hora de verificar los puntos de control** de todo el modelo, esto podría deberse a que la llamada `state_dict()` al modelo u optimizador no se haya realizado en todos los rangos con `rdp_rank()==0` (cuando se utiliza paralelismo de tensores) o `dp_rank()==0` (cuando se utiliza solo paralelismo de canalización). Estos rangos deben comunicarse para construir el punto de control que vaya a guardarse. También pueden ocurrir problemas de estancamiento similares al comprobar el optimizador parcial si `shard_optimizer_state` está habilitado.
Para obtener más información sobre el punto de control de un modelo con paralelismo de modelos, consulte las [Instrucciones generales para guardar y cargar ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) y [Controlar un PyTorch modelo distribuido (para la biblioteca de paralelismo de modelos entre las versiones 1.6.0 y SageMaker 1.9.0)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-saving-loading-checkpoints).
+ Si el trabajo de entrenamiento se bloquea con un **Error de memoria sin memoria CUDA**, esto significa que la configuración de entrenamiento distribuido debe ajustarse para adaptarse al modelo del clúster de GPU. Para obtener más información sobre las prácticas recomendadas, consulte [Establecer la configuración correcta para un modelo determinado](model-parallel-best-practices.md#model-parallel-best-practices-configuration).
+ Si la tarea de formación se interrumpe debido a un **[error de ECC](https://docs.nvidia.com/deploy/a100-gpu-mem-error-mgmt/index.html) incorregible**, significa que una de las GPUs tareas del clúster se ha estropeado. Si necesita soporte técnico, comparta el ARN del trabajo con el equipo de AWS y reinicie su trabajo de entrenamiento desde un punto de control si es posible.
+ En raras ocasiones, una configuración de trabajo que funcionaba anteriormente pero que se aproxima a los límites de la memoria de la GPU podría fallar posteriormente con un clúster diferente debido a un **Error de memoria sin memoria CUDA**. Esto podría deberse a que algunas GPU tienen menos memoria disponible de lo habitual debido a errores de ECC.
+ Es posible **que se interrumpa el tiempo de espera de la red** cuando se ejecuta un trabajo multinodo que no utiliza todo el nodo. GPUs Para evitarlo, usa todo lo que hay GPUs en el nodo asegurándote de que el `processes_per_host` parámetro esté establecido en el número de GPUs en cada instancia. Por ejemplo, esto es `processes_per_host=8` para las instancias `ml.p3.16xlarge`, `ml.p3dn.24xlarge`, y `ml.p4d.24xlarge`.
+ Si descubre que su trabajo de formación lleva mucho tiempo durante la fase de descarga de datos, asegúrese de que la ruta de Amazon S3 que proporcionó `checkpoint_s3_uri` para la SageMaker `Estimator` clase sea única para el trabajo de formación actual. Si esta ruta se reutiliza en varios trabajos de entrenamiento que se ejecutan simultáneamente, todos esos puntos de control se cargan y descargan en la misma ruta de Amazon S3 y podrían aumentar significativamente el tiempo de carga de los puntos de control.
+ Utilice FSx Lustre cuando maneje grandes volúmenes de datos y modelos.
+ [Si tu conjunto de datos es grande y su obtención lleva mucho tiempo, te recomendamos que guardes tu conjunto de datos en LustreFSx .](https://aws.amazon.com/fsx/lustre/)
+ Cuando los modelos de entrenamiento superen los 10 000 millones de parámetros, te recomendamos que utilices Lustre como FSx punto de control.
+ Después de crear un sistema de archivos, asegúrese de esperar a que el estado se convierta en **disponible** antes de comenzar un trabajo de entrenamiento con él.
## Recibir un error de la NCCL para un trabajo de formación PyTorch
Si se produce el siguiente error, podría deberse a un proceso que se está quedando sin memoria de la GPU.
```
NCCL error in: ../torch/lib/c10d/ProcessGroupNCCL.cpp:825, unhandled system error, NCCL version 2.7.8
ncclSystemError: System call (socket, malloc, munmap, etc) failed.
```
Puede resolverlo reduciendo el tamaño del lote o `active_microbatches`. Si la partición automática no da como resultado una partición equilibrada, es posible que deba considerar la creación de particiones manuales. Para obtener más información, consulte [Paralelismo de canalización entre nodos](model-parallel-best-practices.md#model-parallel-best-practices-configuration-pipeline-across-nodes).
## Recibir `RecursionError` un trabajo PyTorch de formación
La biblioteca no admite llamadas `super.forward()` dentro de la llamada de reenvío de un módulo. Si no puede crear `super.forward()`, es posible que reciba el siguiente mensaje de error.
```
RecursionError: maximum recursion depth exceeded
```
Para corregir el error, en lugar de llamar `super.forward()`, debe llamar `super()._orig_forward()`.