Ajuste fino distribuido de un modelo BERT grande para una tarea de respuesta de preguntas usando transformadores de cara abrazada en Amazon SageMaker

Reeditado por Platón

seguidores: 0

Desde entrenar nuevos modelos hasta implementarlos en producción, Amazon SageMaker ofrece el conjunto más completo de herramientas para empresas emergentes y empresas para aprovechar el poder del aprendizaje automático (ML) y el aprendizaje profundo.

Con su biblioteca de código abierto Transformers y su plataforma ML, Hugging Face hace que el aprendizaje de transferencia y los últimos modelos ML sean accesibles para la comunidad global de IA, lo que reduce el tiempo que necesitan los científicos de datos y los ingenieros ML en empresas de todo el mundo para aprovechar cada nuevo conocimiento científico. avance.

La aplicación de Transformers a nuevas tareas o dominios de NLP requiere el ajuste fino de grandes modelos de lenguaje, una técnica que aprovecha el conocimiento acumulado de modelos pre-entrenados para adaptarlos a una nueva tarea o tipo específico de documentos en un proceso de entrenamiento adicional y eficiente.

El ajuste fino del modelo para producir predicciones precisas para el problema comercial en cuestión requiere el entrenamiento de grandes modelos de Transformers, por ejemplo, BERT, BART, RoBERTa, T5, que pueden ser difíciles de realizar de manera escalable.

Hugging Face ha estado trabajando en estrecha colaboración con SageMaker para ofrecer Contenedores de aprendizaje profundo listos para usar (DLC) que hacen que entrenar e implementar los últimos modelos de Transformers sea más fácil y rápido que nunca. Debido a que funciones como SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), S3 pipe mode están integradas en el contenedor, su uso reduce drásticamente el tiempo que tardan las empresas en crear soluciones de aprendizaje automático basadas en Transformers, como la respuesta a preguntas, la generación de texto e imágenes, optimiza los resultados de búsqueda y mejora la automatización de la atención al cliente, las interfaces conversacionales, la búsqueda semántica, el análisis de documentos y muchas más aplicaciones.

En esta publicación, nos enfocamos en la integración profunda de las bibliotecas distribuidas de SageMaker con Hugging Face, que permite a los científicos de datos acelerar el entrenamiento y el ajuste de los modelos de Transformers de días a horas, todo en SageMaker.

Descripción general del entrenamiento distribuido

Los profesionales de ML y los científicos de datos enfrentan dos desafíos de escalado cuando entrenan modelos: escalar el tamaño del modelo (número de parámetros y capas) y escalar los datos de entrenamiento. Escalar el tamaño del modelo o los datos de entrenamiento puede resultar en una mayor precisión, pero puede haber casos en el aprendizaje profundo donde la cantidad de memoria en el acelerador (CPU o GPU) limita la combinación del tamaño de los datos de entrenamiento y el tamaño del modelo. Por ejemplo, cuando se entrena un modelo de lenguaje grande, el tamaño del lote a menudo se limita a una pequeña cantidad de muestras, lo que puede resultar en un modelo menos preciso.

El entrenamiento distribuido puede dividir la carga de trabajo para entrenar el modelo entre múltiples procesadores, llamados los trabajadores.. Estos trabajadores operan en paralelo para acelerar la formación del modelo.

Según lo que queramos escalar (modelo o datos), existen dos enfoques para el entrenamiento distribuido: datos paralelos y modelo paralelo.

El paralelo de datos es el enfoque más común para el entrenamiento distribuido. El paralelismo de datos implica la creación de una copia de la arquitectura del modelo y pesos en diferentes aceleradores. Luego, en lugar de pasar todo el conjunto de entrenamiento a un solo acelerador, podemos dividir el conjunto de entrenamiento entre los diferentes aceleradores y completar el conjunto de entrenamiento más rápido. Si bien esto agrega el paso de los aceleradores que necesitan comunicar su información de gradiente a un servidor de parámetros, esta vez se compensa con creces por el aumento de velocidad de iterar sobre una fracción del conjunto de datos completo por acelerador. Debido a esto, el paralelismo de datos puede ayudar significativamente a reducir los tiempos de entrenamiento. Por ejemplo, entrenar un solo modelo sin paralelización lleva 4 horas. El uso de entrenamiento distribuido puede reducir eso a 24 minutos. El entrenamiento distribuido de SageMaker también implementa técnicas de vanguardia en las actualizaciones de gradiente.

Se utiliza un enfoque de modelo paralelo con modelos grandes demasiado grandes para caber en un acelerador (GPU). Este enfoque implementa una estrategia de paralelización donde la arquitectura del modelo se divide en fragmentos y se coloca en diferentes aceleradores. La configuración de cada uno de estos fragmentos depende de la arquitectura de la red neuronal y normalmente incluye varias capas. La comunicación entre los aceleradores ocurre cada vez que los datos de entrenamiento pasan de uno de los fragmentos al siguiente.

En resumen, debe usar el paralelismo de datos de entrenamiento distribuido para tareas que requieren mucho tiempo debido a grandes conjuntos de datos o cuando desea acelerar sus experimentos de entrenamiento. Debe usar el paralelismo del modelo cuando su modelo no pueda caber en un acelerador.

Requisitos previos

Para realizar un entrenamiento distribuido de los modelos Hugging Face Transformers en SageMaker, debe cumplir los siguientes requisitos previos:

Implementar entrenamiento distribuido

La biblioteca Hugging Face Transformers proporciona una API de entrenador que está optimizada para entrenar o ajustar los modelos que proporciona la biblioteca. También puede usarlo en sus propios modelos si funcionan de la misma manera que los modelos de Transformers; ver Formador para más detalles. Esta API se utiliza en nuestro scripts de ejemplo, que muestran cómo preprocesar los datos para varias tareas de NLP, que puede tomar como modelos para escribir un script que resuelva su propio problema personalizado. La promesa de Trainer API es que este script funciona de forma inmediata en cualquier configuración distribuida, incluido SageMaker.

La API de Entrenador toma todo lo necesario para el entrenamiento. Esto incluye sus conjuntos de datos, su modelo (o una función que devuelve su modelo), un compute_metrics función que devuelve las métricas que desea rastrear de las matrices de predicaciones y etiquetas, su optimizador y programador de tasa de aprendizaje (se proporcionan buenos valores predeterminados), así como todos los hiperparámetros que puede ajustar para su entrenamiento agrupados en una clase de datos llamada TrainingArguments. Con todo eso, expone tres métodos (entrenar, evaluar y predecir) para entrenar su modelo, obtener resultados de métricas en cualquier conjunto de datos u obtener predicciones en cualquier conjunto de datos. Para obtener más información sobre el objeto Entrenador, consulte Ajuste fino de un modelo con Trainer API y el video La API de Entrenador, que lo guía a través de un ejemplo simple.

Detrás de escena, Trainer API comienza analizando el entorno en el que está ejecutando su secuencia de comandos cuando crea el TrainingArguments. Por ejemplo, si inició su capacitación con SageMaker, se ve en el SM_FRAMEWORK_PARAMS variable en el entorno para detectar si habilitó el paralelismo de datos o el paralelismo de modelos de SageMaker. Luego obtiene las variables relevantes (como el rango del proceso o el tamaño mundial) del entorno antes de realizar los pasos de inicialización necesarios (como smdistributed.dataparallel.torch.distributed.init_process_group()).

El Entrenador contiene todo el ciclo de entrenamiento, por lo que puede ajustar los pasos necesarios para asegurarse de que smdistributed.dataparallel backend se usa cuando es necesario sin tener que cambiar una línea de código en su secuencia de comandos. Todavía puede ejecutarse (aunque mucho más lento) en su máquina local para la depuración. Maneja la fragmentación de su conjunto de datos de modo que cada proceso vea diferentes muestras automáticamente, con una reorganización en cada época, sincronizando sus gradientes antes del paso de optimización, entrenamiento de precisión mixto si lo activó, acumulación de gradiente si no puede caber un tamaño de lote grande en sus GPU y muchas más optimizaciones.

Si activó el paralelismo de modelos, se asegura de que los procesos que tienen que ver los mismos datos (si su dp_rank es el mismo) obtienen los mismos lotes, y que los procesos con diferentes dp_rank no vea las mismas muestras, nuevamente con una reorganización en cada época. Se asegura de que los diccionarios de estado del modelo o los optimizadores estén correctamente sincronizados cuando se realizan puntos de control y nuevamente maneja todas las optimizaciones, como la precisión mixta y la acumulación de gradientes.

Al utilizar los métodos de evaluación y predicción, el Entrenador realiza una evaluación distribuida para aprovechar todas sus GPU. Maneja adecuadamente la división de sus datos para cada proceso (proceso del mismo dp_rank si el paralelismo del modelo está activado) y se asegura de que las predicciones se recopilen correctamente en el mismo orden que el conjunto de datos que está utilizando antes de enviarlas al compute_metrics función o simplemente devuelto. El uso de la API de Entrenador no es obligatorio. Los usuarios aún pueden usar Keras o PyTorch dentro de Hugging Face. Sin embargo, Trainer API puede proporcionar una capa de abstracción útil.

Entrene a un modelo con SageMaker Hugging Face Estimators

Un Estimator es una interfaz de alto nivel para la capacitación de SageMaker y maneja tareas integrales de capacitación e implementación de SageMaker. El entrenamiento de su script se invoca cuando llama fit en un HuggingFace Estimador. En el Estimador, usted define qué secuencia de comandos de ajuste fino usar como entry_point, cual instance_type utilizar y qué hiperparámetros se pasan. Para obtener más información sobre HuggingFace parámetros, ver Estimador de cara abrazada.

Entrenamiento distribuido: Paralelo de datos

En este ejemplo, usamos los nuevos DLC Hugging Face y SageMaker SDK para entrenar un modelo de transformador Seq2Seq distribuido en la tarea de preguntas y respuestas usando las bibliotecas de conjuntos de datos y transformadores. los bert-large-sin mayúsculas-enmascaramiento-de-palabras-completas el modelo está ajustado en el equipo conjunto de datos

Los siguientes ejemplos de código le muestran los pasos para crear un HuggingFace estimador para entrenamiento distribuido con paralelismo de datos.

Elija un guión de Transformadores de cara abrazada:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'}

Cuando creas un HuggingFace Estimator, puede especificar un script de capacitación que se almacena en un repositorio de GitHub como punto de entrada para el Estimator, por lo que no tiene que descargar los scripts localmente. Puedes usar git_config para ejecutar los scripts de ejemplos de Hugging Face Transformers y la 'rama' derecha si su transformers_version necesita ser configurado. Por ejemplo, si usa transformers_version 4.6.1, tienes que usar 'branch':'v4.6.1'.

Configure los hiperparámetros de entrenamiento que se pasan al trabajo de entrenamiento:

# hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path': 'bert-large-uncased-whole-word-masking', 'dataset_name':'squad', 'do_train': True, 'do_eval': True, 'fp16': True, 'per_device_train_batch_size': 4, 'per_device_eval_batch_size': 4, 'num_train_epochs': 2, 'max_seq_length': 384, 'max_steps': 100, 'pad_to_max_length': True, 'doc_stride': 128, 'output_dir': '/opt/ml/model'
}

Como hiperparámetro, podemos definir cualquier Seq2SeqTrainingArgumentos y los definidos en el script de entrenamiento.

Definir los parámetros de distribución en el HuggingFace Estimador:

# configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

Puede utilizar el Biblioteca de paralelismo de datos de SageMaker fuera de la caja para el entrenamiento distribuido. Agregamos la funcionalidad de paralelismo de datos directamente en el Entrenador. Para habilitar el paralelismo de datos, simplemente puede agregar un solo parámetro a su HuggingFace Estimator para permitir que su código basado en Entrenador lo use automáticamente.

Créar un HuggingFace Estimador que incluye los parámetros definidos en los pasos anteriores y comienza a entrenar:

from sagemaker.huggingface import HuggingFace
# estimator
huggingface_estimator = HuggingFace(entry_point='run_qa.py', source_dir='./examples/pytorch/question-answering', git_config=git_config, instance_type= 'ml.p3.16xlarge', instance_count= 2, volume_size= 200, role= <SageMaker Role>, # IAM role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', distribution= distribution, hyperparameters = hyperparameters) # starting the train job huggingface_estimator.fit()

El Repositorio de Transformers Hugging Face contiene varios ejemplos y scripts para ajustar modelos en tareas desde el modelado de lenguaje hasta la clasificación de tokens. En nuestro caso, usamos run_qa.py del desplegable examples/pytorch/question-answering ejemplos.

smdistributed.dataparallel admite el entrenamiento de modelos en SageMaker con solo los siguientes tipos de instancias. Para obtener el mejor rendimiento, recomendamos usar un tipo de instancia que admita Adaptador de tela elástica (ALE):

ml.p3.16xgrande
ml.p3dn.24xgrande (Recomendado)
ml.p4d.24xgrande (Recomendado)

Para obtener el mejor rendimiento y el máximo rendimiento SMDataParallel, debe usar al menos dos instancias, pero también puede usar una para probar este ejemplo.

Las siguientes cuaderno de ejemplo proporciona una guía paso a paso más detallada.

Entrenamiento distribuido: modelo paralelo

Para el entrenamiento distribuido con paralelismo de modelos, utilizamos la biblioteca Hugging Face Transformers y conjuntos de datos junto con SageMaker SDK para la clasificación de secuencias en el Evaluación de comprensión del lenguaje general (GLUE) punto de referencia en un clúster de varios nodos y varias GPU utilizando el Biblioteca de paralelismo de modelos de SageMaker.

Al igual que con el paralelismo de datos, primero establecemos la configuración de git, los hiperparámetros de entrenamiento y los parámetros de distribución en el HuggingFace Estimador:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'} # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path':'roberta-large', 'task_name': 'mnli', 'per_device_train_batch_size': 16, 'per_device_eval_batch_size': 16, 'do_train': True, 'do_eval': True, 'do_predict': True, 'num_train_epochs': 2, 'output_dir':'/opt/ml/model', 'max_steps': 500,
} # configuration for running training on smdistributed Model Parallel
mpi_options = { "enabled" : True, "processes_per_host" : 8,
}
smp_options = { "enabled":True, "parameters": { "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "partitions": 4, "ddp": True, }
} distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options
}

La biblioteca de paralelismo de modelos usa internamente MPI, por lo que para usar el paralelismo de modelos, MPI debe estar habilitado usando el parámetro de distribución. “processes_per_host” en el código anterior especifica la cantidad de procesos que MPI debe iniciar en cada host. Sugerimos estos para desarrollo y pruebas. En el momento de la producción, puede ponerse en contacto con AWS Support si solicita una amplia capacidad de GPU. Para más información, ver Ejecutar un trabajo de entrenamiento paralelo de modelo distribuido de SageMaker.

Las siguientes cuaderno de ejemplo contiene los scripts de código completos.

Instancias puntuales

Con la extensión del marco Hugging Face para SageMaker Python SDK, también podemos aprovechar Nube informática elástica de Amazon (Amazon EC2) Instancias puntuales y ahorre hasta un 90% de nuestro costo de capacitación.

A menos que su trabajo de entrenamiento se complete rápidamente, le recomendamos que use punto de control con entrenamiento puntual administrado, por lo tanto, debe definir checkpoint_s3_uri.

Para usar Instancias de spot con el HuggingFace Estimador, tenemos que establecer el use_spot_instances parámetro a Verdadero y defina su max_wait y max_run tiempo. Para obtener más información sobre el ciclo de vida de entrenamiento de spot administrado, consulte Capacitación Spot administrada en Amazon SageMaker.

El siguiente es un fragmento de código para configurar un Estimador de entrenamiento puntual:

from sagemaker.huggingface import HuggingFace # hyperparameters, which are passed into the training job
hyperparameters={'epochs': 1, 'train_batch_size': 32, 'model_name':'distilbert-base-uncased', 'output_dir':'/opt/ml/checkpoints' } # s3 uri where our checkpoints will be uploaded during training
job_name = "using-spot"
checkpoint_s3_uri = f's3://{sess.default_bucket()}/{job_name}/checkpoints' huggingface_estimator = HuggingFace(entry_point='train.py', source_dir='./scripts', instance_type='ml.p3.2xlarge', instance_count=1, base_job_name=job_name, checkpoint_s3_uri=checkpoint_s3_uri, use_spot_instances=True, max_wait=3600, # This should be equal to or greater than max_run in seconds' max_run=1000, # expected max run in seconds role=role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', hyperparameters = hyperparameters)

Las siguientes cuaderno contiene los scripts de código completos.

Conclusión

En esta publicación, discutimos el entrenamiento distribuido de Hugging Face Transformers usando SageMaker. Primero revisamos los casos de uso para el paralelismo de datos frente al paralelismo de modelos. El paralelismo de datos suele ser más apropiado, pero no necesariamente se limita a cuando el entrenamiento se ve obstaculizado por la computación, mientras que puede usar el paralelismo de modelos cuando un modelo no cabe en la memoria provista en un solo acelerador. Luego mostramos cómo entrenar con ambos métodos.

En el caso de uso de paralelismo de datos que discutimos, entrenar un modelo en una sola instancia p3.2xlarge (con una sola GPU) toma 4 horas y cuesta aproximadamente $15 al momento de escribir este artículo. Con el paralelismo de datos, podemos entrenar el mismo modelo en 24 minutos a un costo de $28. Aunque el costo se ha duplicado, esto ha reducido el tiempo de entrenamiento por un factor de 10. Para una situación en la que necesita entrenar muchos modelos dentro de un corto período de tiempo, el paralelismo de datos puede permitir esto a un aumento de costo relativamente bajo. En cuanto al caso de uso de paralelismo de modelos, agrega la capacidad de entrenar modelos que no podrían haber sido entrenados previamente debido a limitaciones de hardware. Ambas características permiten nuevos flujos de trabajo para los profesionales de ML y son fácilmente accesibles a través del HuggingFace Estimator como parte del SDK de Python de SageMaker. La implementación de estos modelos en puntos finales alojados sigue el mismo procedimiento que para otros estimadores.

Esta integración habilita otras funciones que forman parte del ecosistema de SageMaker. Por ejemplo, puede usar Instancias de spot agregando un indicador simple al Estimador para una optimización de costos adicional. Como siguiente paso, puede encontrar y ejecutar el demostración de entrenamiento y cuaderno de ejemplo.

Acerca de los autores

Archis Joglekar es un arquitecto de soluciones de socios de AI / ML en el equipo de Tecnologías Emergentes. Está interesado en el aprendizaje profundo escalable y de alto rendimiento y la computación científica utilizando los componentes básicos de AWS. Sus experiencias pasadas van desde la investigación en física computacional hasta el desarrollo de plataformas de aprendizaje automático en el mundo académico, laboratorios nacionales y nuevas empresas. Su tiempo fuera de la computadora lo pasa jugando al fútbol y con amigos y familiares.

james yi es Arquitecto Sr. de Soluciones de Socios de AI/ML en el equipo de Tecnologías Emergentes en Amazon Web Services. Le apasiona trabajar con clientes y socios empresariales para diseñar, implementar y escalar aplicaciones AI/ML para derivar sus valores comerciales. Fuera del trabajo, le gusta jugar fútbol, viajar y pasar tiempo con su familia.

Felipe Schmid es ingeniero de aprendizaje automático y líder tecnológico en Hugging Face, donde lidera la colaboración con el equipo de Amazon SageMaker. Le apasiona democratizar, optimizar y producir modelos de NLP de vanguardia y mejorar la facilidad de uso del aprendizaje profundo.

Sylvain Gugger es ingeniero de investigación en Hugging Face y uno de los principales mantenedores de la biblioteca de Transformers. Le encanta el software de código abierto y ayudar a la comunidad a usarlo.

jeff boudier crea productos en Hugging Face, creador de Transformers, la principal biblioteca de aprendizaje automático de código abierto. Anteriormente, Jeff fue cofundador de Stupeflix, adquirida por GoPro, donde se desempeñó como director de Gestión de productos, Marketing de productos, Desarrollo comercial y Desarrollo corporativo.