Entrene modelos gigantes con escalado casi lineal utilizando paralelismo de datos fragmentados en Amazon SageMaker

En la búsqueda de una precisión superior, los modelos de aprendizaje profundo en áreas como el procesamiento del lenguaje natural y la visión por computadora han crecido significativamente en tamaño en los últimos años, frecuentemente contados en decenas a cientos de miles de millones de parámetros. Entrenar estos modelos gigantes es un desafío y requiere estrategias de distribución complejas. Los científicos de datos y los ingenieros de aprendizaje automático buscan constantemente la mejor manera de optimizar su cómputo de entrenamiento, pero tienen dificultades con la sobrecarga de comunicación que puede aumentar junto con el tamaño general del clúster.

Es por eso que lanzamos recientemente sparalelismo de datos duros on Amazon SageMaker, una nueva técnica de entrenamiento distribuido que ahorra memoria en el Biblioteca de modelos paralelos (SMP) de SageMaker. El paralelismo de datos fragmentados está diseñado específicamente para modelos de escala extrema y utiliza Amazon internamente micrófonos tecnología bajo el capó, un esfuerzo científico para minimizar la escala de comunicación al reducir la costosa sobrecarga de comunicación arraigada en la recopilación de parámetros y la sincronización de gradientes. Con un modelo GPT-30 de parámetros 2B con una longitud de secuencia de 2048, esta nueva característica logró 141 TFLOP, un 39.7 % de aceleración en comparación con DeepSpeed ​​ZeRO-3. Para un modelo 10B GPT-2 con una longitud de secuencia de 512, esta nueva función también logró 564 muestras por segundo, un 13.9 % más de velocidad en comparación con el paralelo de datos totalmente fragmentado (FSDP) de PyTorch. Recuerde que en el entrenamiento de modelos gigantes, cada porcentaje de aceleración se traduce en dólares ahorrados y productividad ganada en su equipo.

En esta publicación de blog, primero veremos más de cerca los diferenciadores clave del paralelismo de datos fragmentados y cuándo usarlo. Luego, aprenderá a entrenar fácilmente un modelo GPT-30 de parámetros 2B en SageMaker con esta nueva función. Finalmente, compararemos el rendimiento con otras opciones de código abierto, superando notablemente a DeepSpeed ​​ZeRO hasta en un 39.7 % en 256 GPU.

Cómo funciona el paralelismo de datos fragmentados y cuándo usarlo

Antes de presentar el paralelismo de datos fragmentados, veamos su familia de técnicas más amplia. Los enfoques de entrenamiento distribuido recientes para modelos grandes se han movido a un paradigma en el que los parámetros del modelo, los gradientes y los estados del optimizador se comparten entre nodos de datos paralelos. A diferencia de Pipeline Parallelism, que tiene la complejidad innata de elegir capas para particionar entre dispositivos, especialmente cuando su marco no admite división automática de modelos, este paradigma conserva elegantemente la simplicidad del paralelismo de datos, al tiempo que elimina la restricción del paralelismo de datos donde un modelo debe caber en una sola GPU.

En los marcos existentes que caen bajo este paradigma, en particular DeepSpeed ​​ZeRO-3 y PyTorch's FSDP upstreamed from FairScale, los estados del modelo se fragmentan en todos GPU, una estrategia que reduce el consumo de memoria en cada GPU a costa de incurrir en una gran sobrecarga de comunicación que aumenta con el tamaño del clúster y, por lo tanto, hace que la escalabilidad disminuya significativamente a escala. Por el contrario, el paralelismo de datos fragmentados en los estados del modelo de particiones de la biblioteca SMP en un consciente de la escala forma mediante la partición de cada réplica de los estados del modelo sólo dentro de un subconjunto de GPU.

Miremos más de cerca el particionamiento de modelo consciente de la escala en MiCS, la tecnología central detrás de los datos fragmentados en paralelo. La intuición detrás de este diseño es que es posible que no se requiera dividir los estados de entrenamiento en todo el grupo de datos paralelos para entrenar un modelo con decenas de miles de millones de parámetros. Por ejemplo, 8 GPU V100 (32 GB cada una) son suficientes para mantener la réplica de los estados del modelo de un modelo de parámetros 10B que necesita alrededor de 200 GB de memoria cuando se entrena con el optimizador Adam con precisión mixta. Al limitar una réplica completa de los estados del modelo en el más pequeño subconjunto de GPU, podemos reducir efectivamente la escala de la sobrecarga de comunicación en comparación con DeepSpeed ​​y PyTorch FSDP. El paralelo de datos fragmentados también aprovecha otras técnicas en MiCS, como la comunicación jerárquica y la sincronización de gradiente de 2 saltos. Para obtener más información, consulte Escalado casi lineal del entrenamiento de modelos gigantes en AWS or MiCS: escalado casi lineal para entrenar un modelo gigante en la nube pública.

Ahora, ¿cómo sabe cuándo elegir datos fragmentados en paralelo en lugar de otras técnicas de entrenamiento distribuidas? La regla general es que si su modelo tiene menos de mil millones de parámetros y cabe en la memoria de la GPU, Biblioteca paralela de datos de SageMaker or Compilador de entrenamiento de SageMaker puede ser suficiente para usted. Si tiene modelos de lenguaje más grandes o de visión por computadora, nuestra sugerencia es entrenarlo con la técnica de paralelismo de datos fragmentados combinada con punto de control de activación y descarga de activación primero en la biblioteca paralela de modelos de SageMaker, antes de otras técnicas como paralelismo tensorial o paralelismo de tubería.

Uso del paralelismo de datos fragmentados para entrenar GPT-2 en Amazon SageMaker

Ahora aprendamos cómo entrenar un modelo GPT-2 con datos fragmentados en paralelo, con SMP encapsulando la complejidad por usted. Este cuaderno tutorial completo lo guía a través de todo el proceso, desde el procesamiento de datos, la definición y el envío de trabajos de capacitación hasta la supervisión de los registros de capacitación. Lo que sigue es una breve descripción general que destaca los pasos clave para usar esta función.

1. Empezar

El paralelismo de datos fragmentados está disponible en PyTorch v1.12.0+ y funciona con FP16 y BF16. La forma más fácil de usar la biblioteca SMP es a través de un contenedor de aprendizaje profundo de AWS preconstruido para PyTorch. Sin embargo, si desea traer su propio contenedor Docker, puede consultar Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos de SageMaker. Para empezar, sigue Modificar un script de entrenamiento de PyTorch para adaptar las API de SMP en su script de entrenamiento. En esta sección, solo mencionamos algunos pasos principales con fragmentos de código del script de capacitación listo para usar. train_gpt_simple.py. Puedes seguir los comentarios en el script y Documento API para obtener más información sobre dónde se utilizan las API de SMP.

Primero, importe e inicialice la biblioteca llamando smdistributed.modelparallel.torch.init() al comienzo del script de entrenamiento:

import smdistributed.modelparallel.torch as smp

smp.init(smp_config)

En segundo lugar, envuelva el modelo a particionar con smdistributed.modelparallel.torch.DistributedModel y usa el devuelto DistributedModel objeto en el futuro:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_config(model_config)
model = smp.DistributedModel(model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation)

Envuelva el optimizador con smdistributed.modelparallel.torch.DistributedOptimizer para guardar y cargar estados del optimizador.

from torch import optim

optimizer = optim.Adam(
    param_groups, betas=(args.beta1, args.beta2), lr=args.lr, weight_decay=args.weight_decay
)

optimizer = smp.DistributedOptimizer(
        optimizer, 
        static_loss_scale=None, 
        dynamic_loss_scale=True,
        dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
        )

Ponga la lógica de avance y retroceso en una función de paso y decórela con smdistributed.modelparallel.torch.step.  Cualquier cálculo definido dentro del smp.step-decorated La función se ejecuta de forma distribuida.

@smp.step
def train_step(model, optimizer, input_ids, attention_mask, args):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    model.backward(loss)

    return loss

@smp.step
def test_step(model, input_ids, attention_mask):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    
    return loss

2. Preparar el conjunto de datos

Usamos la textowebabierto es el conjunto de datos que usamos en este ejemplo. El cuaderno usa el script. data_prep_512.py para descargar y preprocesar el conjunto de datos. También puede entrenar con otros conjuntos de datos modificando data_pipeline.py. Cuando se trata de conjuntos de datos y modelos grandes, puede acelerar el trabajo de entrenamiento utilizando datos almacenados en Amazon FSx para Lustre, que proporciona un sistema de archivos de alto rendimiento integrado de forma nativa con Servicio de almacenamiento simple de Amazon (S3). Consulte las instrucciones de Configurar el canal de entrada de datos para utilizar Amazon FSx for Lustre para obtener orientación sobre cómo configurar un sistema de archivos FSx Lustre como canal de entrada de datos.

3. Iniciar los trabajos de formación

Este paso asume que ya ha modificó su guión de entrenamiento y preparó el conjunto de datos como se menciona en las secciones anteriores. A habilite el paralelismo de datos fragmentados, simplemente configure el sharded_data_parallel_degree existentes Estimador PyTorch. En este tutorial, configuramos sharded_data_parallel_degree=128 y instace_count=32 para los nodos p4d.24xlarge, lo que indica que los estados del modelo se dividirán en 128 GPU del total de 256 GPU. Según este valor seleccionado, SMP establecerá automáticamente el grado de paralelismo de datos en 2 (porque 256/128=2), lo que significa que tendremos dos réplicas para el paralelismo de datos. Una regla general para escoger un valor ideal para sharded_data_parallel_degree es agregar un nodo más al grupo compartido por cada 3B de parámetros del modelo. En este tutorial, el tamaño de nuestro modelo es 30B, por lo que debemos usar al menos 10 nodos para la fragmentación. Y debido a que 16 nodos (128 GPU) es la potencia de 2 más pequeña por encima del umbral, configuramos sharded_data_parallel_degree=128.

Para los puntos de control, también proporcionamos un conjunto de utilidades de puntos de control en sharded_data_parallel_checkpoint.py , incluyendo una utilidad para reconstruir la totalidad state_dict para casos de uso avanzado. Finalmente, podemos lanzar un trabajo de entrenamiento distribuido llamando a fit() en el Estimator.

smp_estimator = PyTorch(
    entry_point="train_gpt_simple.py",
    instance_type="ml.p4d.24xlarge",
    source_dir=os.getcwd(),
    volume_size=500,
    instance_count=32,
    distribution={
        "mpi": {
            "enabled": True,
            "processes_per_host": processes_per_host,
            "custom_mpi_options": mpioptions,
        },
        "smdistributed": {
            "modelparallel": {
                "enabled": True,
                "parameters": {
                    "ddp": True,
                    "skip_tracing": True,
                    "delayed_parameter_initialization": True,
                    "offload_activations": True,
                    "activation_loading_horizon": 4,
                    # To enable sharded data parallelism.
                    # Here we shard model states across 128 GPUs. 
                    "sharded_data_parallel_degree": 128, 
                    "fp16": False,
                    "bf16": True,
                    # This is to disable pipeline parallelism.
                    "partitions": 1,
                },
            }
        },
    },
    framework_version="1.12",
    py_version="py38",
    hyperparameters=hyperparameters,
    checkpoint_s3_uri=checkpoint_s3_uri if not use_fsx else None,
    checkpoint_local_path=hyperparameters["checkpoint-dir"] if use_fsx else None,
    ...
)

smp_estimator.fit(inputs=data_channels)

4. Supervisar los trabajos de formación

Puede acceder a los registros de entrenamiento y realizar un seguimiento de la utilización de GPU y memoria en Reloj en la nube de Amazon. Asegúrate de mirar los registros de “algo-1” porque ese es el nodo principal cuyo flujo de salida tiene los registros de trabajo de entrenamiento de todas las instancias.

Rendimiento de evaluación comparativa

Evaluamos el paralelismo de datos fragmentados en la biblioteca SMP en 16 y 32 nodos p4d.24xlarge para longitudes de secuencia de 512 y 2048, respectivamente. El modelo GPT30 de parámetros 2B está configurado para usar un ancho oculto de 7168, 48 capas y 64 cabezales. Puede adoptar exactamente la misma configuración donde la longitud de la secuencia es 2048 configurando model_config = "gpt2-30b" en el cuaderno de tutoriales. Con esta configuración, SMP logró 73.52 muestras por segundo, una aceleración del 39.7 % en comparación con DeepSpeed ​​ZeRO-3. Si el tamaño de su token es de 500 367 millones, esta aceleración significa casi 4 horas de ahorro en nodos p24d.12,000xlarge, ¡un equivalente a más de $XNUMX XNUMX de presupuesto ahorrado por capacitación! La siguiente tabla resume nuestros resultados de referencia.

1/ Para cada configuración de modelo, probamos diferentes funciones, etapas y configuraciones en DeepSpeed ​​ZeRO y elegimos la que proporciona el mejor rendimiento como base de DeepSpeed. El punto de referencia se ejecutó en Nube informática elástica de Amazon (Amazon EC2). 2/ Estos resultados se basan en colectivos de comunicación mejorados optimizados para AWS que estarán disponibles pronto. 3/ El tiempo para entrenar se proyecta a partir de la velocidad en función del número de fichas procesadas.

En resumen, observamos un rendimiento consistentemente más alto con el paralelismo de datos fragmentados en SMP en comparación con DeepSpeed ​​en una variedad de modelos y configuraciones. Esta nueva característica también demostró una mejor eficiencia de la memoria en comparación con DeepSpeed, lo que permite que SMP se adapte a un tamaño de lote más grande y reduzca el nivel de acumulación de gradiente necesario para adaptarse a un tamaño de lote global particular.

Conclusión

En esta publicación, presentamos una nueva técnica de entrenamiento distribuido, el paralelismo de datos fragmentados, y cómo acelera el entrenamiento de modelos gigantes con un escalado casi lineal en Amazon SageMaker. También explicamos cómo entrenar un modelo GPT-2 con la nueva técnica siguiendo este ejemplo completo. Puedes seguir el Ejemplos de repositorio de GitHub de Amazon SageMaker para realizar un seguimiento de todos los ejemplos paralelos de modelos de SageMaker o asistir a nuestro próximo talleres de formación distribuidos. Para obtener más información sobre el paralelismo de datos fragmentados, consulte la documentación.

Sobre los autores

emilio webber se unió a AWS justo después del lanzamiento de SageMaker y ha estado tratando de contárselo al mundo desde entonces. Además de crear nuevas experiencias de aprendizaje automático para los clientes, a Emily le gusta meditar y estudiar el budismo tibetano.

Can Karakus es un científico aplicado sénior en AWS, que optimiza el aprendizaje profundo distribuido a gran escala en AWS. Sus intereses de investigación abarcan el aprendizaje profundo, la optimización distribuida, los sistemas distribuidos y la teoría de la información. Fuera del trabajo, disfruta andar en bicicleta, viajar, leer y aprender.

Raúl Huilgol es ingeniero de software sénior en AWS. Trabaja en sistemas de aprendizaje profundo distribuidos, para que sea fácil y eficaz entrenar grandes modelos de aprendizaje profundo en la nube. En su tiempo libre, disfruta de la fotografía, andar en bicicleta y la jardinería.

Suhit Kódgule es un ingeniero de desarrollo de software del grupo de inteligencia artificial de AWS que trabaja en marcos de aprendizaje profundo. En su tiempo libre le gusta caminar, viajar y cocinar.

erin ho es gerente de producto de AWS Deep Learning. Trabaja en productos que facilitan a los clientes la capacitación de modelos de aprendizaje profundo en AWS. Para divertirse fuera del trabajo, le gusta caminar y esquiar.