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