Entrenamiento distribuido Entrena BART/T5 para resumir utilizando 🤗 Transformers y Amazon SageMaker

Entrenamiento distribuido de BART/T5 utilizando 🤗 Transformers y Amazon SageMaker para resumir.

En caso de que te lo hayas perdido: el 25 de marzo anunciamos una colaboración con Amazon SageMaker para facilitar la creación de modelos de aprendizaje automático de última generación y enviar funciones de procesamiento de lenguaje natural de vanguardia de forma más rápida.

Junto con el equipo de SageMaker, creamos contenedores de aprendizaje profundo optimizados por 🤗 Transformers para acelerar el entrenamiento de modelos basados en Transformers. ¡Gracias amigos de AWS! 🤗 🚀

Con el nuevo estimador de HuggingFace en el SDK de Python de SageMaker, puedes comenzar a entrenar con una sola línea de código.

• Escalando la inferencia de BERT en CPU (Parte 1)
• Utilizando y mezclando modelos de Hugging Face con Gradio 2.0
• Transformadores de oraciones en el Hugging Face Hub

La publicación del blog de anuncio proporciona toda la información que necesitas saber sobre la integración, incluido un ejemplo de “Introducción” y enlaces a documentación, ejemplos y características.

listado nuevamente aquí:

• 🤗 Documentación de Transformers: Amazon SageMaker
• Cuadernos de ejemplo
• Documentación de Amazon SageMaker para Hugging Face
• Documentación de Python SDK de SageMaker para Hugging Face
• Contenedor de aprendizaje profundo

Si no estás familiarizado con Amazon SageMaker: “Amazon SageMaker es un servicio completamente administrado que brinda a cada desarrollador y científico de datos la capacidad de crear, entrenar e implementar modelos de aprendizaje automático (ML) rápidamente. SageMaker elimina la carga pesada de cada paso del proceso de aprendizaje automático para facilitar el desarrollo de modelos de alta calidad”. [ REF ]

---

Utilizaremos los nuevos DLC de Hugging Face y la extensión de Amazon SageMaker para entrenar un modelo de transformador Seq2Seq distribuido en la tarea de resumen utilizando las bibliotecas transformers y datasets, y luego cargaremos el modelo en huggingface.co y lo probaremos.

Como estrategia de entrenamiento distribuido, vamos a utilizar Paralelismo de Datos de SageMaker, que ha sido incorporado en la API de Entrenador. Para usar el paralelismo de datos, solo tenemos que definir el parámetro distribution en nuestro estimador HuggingFace.

# configuración para ejecutar el entrenamiento en smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

En este tutorial, utilizaremos una instancia de Amazon SageMaker Notebook para ejecutar nuestro trabajo de entrenamiento. Puedes aprender aquí cómo configurar una instancia de Notebook .

¿Qué vamos a hacer:

• Configurar un entorno de desarrollo e instalar sagemaker
• Elegir el script examples/ de 🤗 Transformers
• Configurar el entrenamiento distribuido e hiperparámetros
• Crear un estimador HuggingFace y comenzar el entrenamiento
• Cargar el modelo afinado en huggingface.co
• Probar la inferencia

Modelo y Conjunto de datos

Vamos a afinar el modelo facebook/bart-large-cnn en el conjunto de datos samsum. “BART es un modelo de secuencia a secuencia entrenado con el objetivo de preentrenamiento con eliminación de ruido”. [ REF ]

El conjunto de datos samsum contiene aproximadamente 16k conversaciones similares a las de Messenger con resúmenes.

{"id": "13818513",
 "summary": "Amanda hizo galletas y le llevará algunas a Jerry mañana.",
 "dialogue": "Amanda: Hice galletas. ¿Quieres algunas?\r\nJerry: ¡Claro!\r\nAmanda: Te las llevaré mañana :-)"}

---

Configurar un entorno de desarrollo e instalar sagemaker

Después de que nuestra instancia de SageMaker Notebook esté en funcionamiento, podemos seleccionar ya sea Jupyer Notebook o JupyterLab y crear un nuevo Notebook con el kernel conda_pytorch_p36.

Nota: El uso de Jupyter es opcional: También podríamos lanzar trabajos de entrenamiento de SageMaker desde cualquier lugar donde tengamos instalado un SDK, conectividad a la nube y permisos apropiados, como una computadora portátil, otro IDE o un programador de tareas como Airflow o AWS Step Functions.

Después de eso, podemos instalar las dependencias necesarias

!pip install transformers "datasets[s3]" sagemaker --upgrade

instalar git-lfs para la carga del modelo.

!curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.rpm.sh | sudo bash
!sudo yum install git-lfs -y
!git lfs install

Para ejecutar el entrenamiento en SageMaker, necesitamos crear una sesión de sagemaker y proporcionar un rol IAM con los permisos adecuados. Este rol IAM se adjuntará más tarde al TrainingJob permitiéndole descargar datos, por ejemplo, desde Amazon S3.

import sagemaker

sess = sagemaker.Session()
role = sagemaker.get_execution_role()

print(f"Rol IAM arn utilizado para ejecutar el entrenamiento: {role}")
print(f"Cubo S3 utilizado para almacenar artefactos: {sess.default_bucket()}")

---

El repositorio de 🤗 Transformers contiene varios scripts examples/ para ajustar modelos en tareas desde language-modeling hasta token-classification. En nuestro caso, estamos utilizando el run_summarization.py de los ejemplos seq2seq/.

Nota: puedes utilizar este tutorial tal cual para entrenar tu modelo en un script de ejemplo diferente.

Dado que el Estimador HuggingFace tiene soporte integrado para git, podemos especificar un script de entrenamiento almacenado en un repositorio de GitHub como entry_point y source_dir.

Vamos a utilizar el DLC transformers 4.4.2, lo que significa que debemos configurar el v4.4.2 como la rama para extraer los scripts de ejemplo compatibles.

#git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.4.2'} # v4.4.2 se refiere a la versión `transformers_version` que se utiliza en el estimador.
# utilizado debido a un paquete faltante en v4.4.2
git_config = {'repo': 'https://github.com/philschmid/transformers.git','branch': 'master'} # v4.4.2 se refiere a la versión `transformers_version` que se utiliza en el estimador.

---

Configurar entrenamiento distribuido e hiperparámetros

A continuación, definiremos nuestros hiperparámetros y configuraremos nuestra estrategia de entrenamiento distribuido. Como hiperparámetro, podemos definir cualquier argumento Seq2SeqTrainingArguments y los definidos en run_summarization.py.

# hiperparámetros, que se pasan al trabajo de entrenamiento
hiperparametros={
    'per_device_train_batch_size': 4,
    'per_device_eval_batch_size': 4,
    'model_name_or_path':'facebook/bart-large-cnn',
    'dataset_name':'samsum',
    'do_train':True,
    'do_predict': True,
    'predict_with_generate': True,
    'output_dir':'/opt/ml/model',
    'num_train_epochs': 3,
    'learning_rate': 5e-5,
    'seed': 7,
    'fp16': True,
}

# configuración para ejecutar el entrenamiento en smdistributed Data Parallel
distribucion = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

Dado que estamos utilizando SageMaker Data Parallelism, nuestro total_batch_size será per_device_train_batch_size * n_gpus.

---

Crear un estimador HuggingFace y comenzar el entrenamiento

El último paso antes del entrenamiento es crear un estimador HuggingFace. El Estimador se encarga del entrenamiento de Amazon SageMaker de principio a fin. Definimos qué script de ajuste fino se debe utilizar como entry_point, qué instance_type se debe utilizar y qué hiperparámetros se pasan.

from sagemaker.huggingface import HuggingFace

# crear el Estimador
estimador_huggingface = HuggingFace(
      entry_point='run_summarization.py', # script
      source_dir='./examples/seq2seq', # ruta relativa al ejemplo
      git_config=git_config,
      instance_type='ml.p3dn.24xlarge',
      instance_count=2,
      transformers_version='4.4.2',
      pytorch_version='1.6.0',
      py_version='py36',
      role=role,
      hiperparametros = hiperparametros,
      distribucion = distribucion
)

Como instance_type estamos utilizando ml.p3dn.24xlarge, que contiene 8x NVIDIA A100 con un instance_count de 2. Esto significa que vamos a ejecutar el entrenamiento en 16 GPUs y un total_batch_size de 16*4=64. Vamos a entrenar un modelo con 400 millones de parámetros con un total_batch_size de 64, lo cual es impresionante. Para iniciar nuestro entrenamiento, llamamos al método .fit().

# comenzando el trabajo de entrenamiento
huggingface_estimator.fit()

2021-04-01 13:00:35 Inicio - Iniciando el trabajo de entrenamiento...
2021-04-01 13:01:03 Inicio - Lanzando instancias de ML solicitadasProfilerReport-1617282031: En progreso
2021-04-01 13:02:23 Inicio - Preparando las instancias para el entrenamiento......
2021-04-01 13:03:25 Descargando - Descargando datos de entrada...
2021-04-01 13:04:04 Entrenamiento - Descargando la imagen de entrenamiento...............
2021-04-01 13:06:33 Entrenamiento - Descarga de imagen de entrenamiento completada. Entrenamiento en progreso
....
....
2021-04-01 13:16:47 Subiendo - Subiendo modelo de entrenamiento generado
2021-04-01 13:27:49 Completado - Trabajo de entrenamiento completado
Segundos de entrenamiento: 2882
Segundos facturables: 2882

Los segundos de entrenamiento son 2882 porque se multiplican por el número de instancias. Si calculamos 2882/2=1441, es la duración desde “Descargando la imagen de entrenamiento” hasta “Trabajo de entrenamiento completado”. Convertido a dinero real, nuestro entrenamiento en 16 NVIDIA Tesla V100-GPU para un modelo de resumen de última generación se reduce a ~28$.

---

Subir el modelo ajustado a huggingface.co

Dado que nuestro modelo ha obtenido una puntuación bastante buena, lo vamos a subir a huggingface.co, crear una model_card y probarlo con el widget de Inferencia alojada. Para subir un modelo, debes crear una cuenta aquí .

Podemos descargar nuestro modelo desde Amazon S3 y descomprimirlo utilizando el siguiente fragmento de código.

import os
import tarfile
from sagemaker.s3 import S3Downloader

local_path = 'mi_modelo_bart'

os.makedirs(local_path, exist_ok = True)

# descargar modelo desde S3
S3Downloader.download(
    s3_uri=huggingface_estimator.model_data, # uri de S3 donde se encuentra el modelo entrenado
    local_path=local_path, # ruta local donde se guardará *.tar.gz
    sagemaker_session=sess # sesión de sagemaker utilizada para entrenar el modelo
)

# descomprimir modelo
tar = tarfile.open(f"{local_path}/model.tar.gz", "r:gz")
tar.extractall(path=local_path)
tar.close()
os.remove(f"{local_path}/model.tar.gz")

Antes de subir nuestro modelo a huggingface.co, necesitamos crear una model_card. La model_card describe el modelo e incluye hiperparámetros, resultados y especifica qué conjunto de datos se utilizó para el entrenamiento. Para crear una model_card, creamos un README.md en nuestra local_path

# leer resultados de evaluación y prueba
with open(f"{local_path}/eval_results.json") as f:
    eval_results_raw = json.load(f)
    eval_results={}
    eval_results["eval_rouge1"] = eval_results_raw["eval_rouge1"]
    eval_results["eval_rouge2"] = eval_results_raw["eval_rouge2"]
    eval_results["eval_rougeL"] = eval_results_raw["eval_rougeL"]
    eval_results["eval_rougeLsum"] = eval_results_raw["eval_rougeLsum"]

with open(f"{local_path}/test_results.json") as f:
    test_results_raw = json.load(f)
    test_results={}
    test_results["test_rouge1"] = test_results_raw["test_rouge1"]
    test_results["test_rouge2"] = test_results_raw["test_rouge2"]
    test_results["test_rougeL"] = test_results_raw["test_rougeL"]
    test_results["test_rougeLsum"] = test_results_raw["test_rougeLsum"]

Después de extraer todas las métricas que queremos incluir, vamos a crear nuestro README.md. Además de la generación automatizada de la tabla de resultados, agregamos manualmente las métricas al metadata de nuestra tarjeta de modelo en model-index

import json

PLANTILLA_MODEL_CARD = """
---
language: es
tags:
- sagemaker
- bart
- resumen
licencia: apache-2.0
conjuntos de datos:
- samsum
model-index:
- name: {nombre_modelo}
  results:
  - task: 
      name: Resumen Abstractivo de Texto
      type: resumen-abstractivo-de-texto
    dataset:
      name: "SAMSum Corpus: Un conjunto de datos de diálogos anotados por humanos para resumen abstractivo" 
      type: samsum
    metrics:
       - name: ROUGE-1 de validación
         type: rouge-1
         value: 42.621
       - name: ROUGE-2 de validación
         type: rouge-2
         value: 21.9825
       - name: ROUGE-L de validación
         type: rouge-l
         value: 33.034
       - name: ROUGE-1 de prueba
         type: rouge-1
         value: 41.3174
       - name: ROUGE-2 de prueba
         type: rouge-2
         value: 20.8716
       - name: ROUGE-L de prueba
         type: rouge-l
         value: 32.1337
widget:
- text: | 
    Jeff: ¿Puedo entrenar un modelo de 🤗 Transformers en Amazon SageMaker? 
    Philipp: Claro, puedes usar el nuevo contenedor de Hugging Face Deep Learning. 
    Jeff: Ok.
    Jeff: y ¿cómo puedo empezar? 
    Jeff: ¿dónde puedo encontrar documentación? 
    Philipp: ok, ok puedes encontrar todo aquí. https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face 
---

## `{nombre_modelo}`

Este modelo fue entrenado utilizando Amazon SageMaker y el nuevo contenedor de Hugging Face Deep Learning.

Para obtener más información, consulta:
- [Documentación de 🤗 Transformers: Amazon SageMaker](https://huggingface.co/transformers/sagemaker.html)
- [Cuadernos de ejemplo](https://github.com/huggingface/notebooks/tree/master/sagemaker)
- [Documentación de Amazon SageMaker para Hugging Face](https://docs.aws.amazon.com/sagemaker/latest/dg/hugging-face.html)
- [Documentación de SDK de Python SageMaker para Hugging Face](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html)
- [Contenedor de Deep Learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers)

## Hiperparámetros

    {hiperparámetros}


## Uso
    from transformers import pipeline
    summarizer = pipeline("summarization", model="philschmid/{nombre_modelo}")

    conversación = '''Jeff: ¿Puedo entrenar un modelo de 🤗 Transformers en Amazon SageMaker? 
    Philipp: Claro, puedes usar el nuevo contenedor de Hugging Face Deep Learning. 
    Jeff: Ok.
    Jeff: y ¿cómo puedo empezar? 
    Jeff: ¿dónde puedo encontrar documentación? 
    Philipp: ok, ok puedes encontrar todo aquí. https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face                                           
    '''
    nlp(conversación)

## Resultados

| clave | valor |
| ----- | ----- |
{tabla_evaluación}
{tabla_prueba}



"""

# Generar model_card (todo: añadir más datos del Entrenador)
model_card = PLANTILLA_MODEL_CARD.format(
    nombre_modelo=f"{hiperparámetros['model_name_or_path'].split('/')[1]}-{hiperparámetros['dataset_name']}",
    hiperparámetros=json.dumps(hiperparámetros, indent=4, sort_keys=True),
    tabla_evaluación="\n".join(f"| {k} | {v} |" for k, v in eval_results.items()),
    tabla_prueba="\n".join(f"| {k} | {v} |" for k, v in test_results.items()),
)

with open(f"{local_path}/README.md", "w") as f:
    f.write(model_card)

Después de tener nuestro modelo descomprimido y la tarjeta de modelo ubicada en mi_modelo_bart, podemos utilizar el SDK de huggingface_hub para crear un repositorio y subirlo a huggingface.co, o simplemente ir a https://huggingface.co/new y crear un nuevo repositorio y subirlo.

from getpass import getpass
from huggingface_hub import HfApi, Repository

hf_username = "philschmid" # tu nombre de usuario en huggingface.co
hf_email = "[email protected]" # correo electrónico utilizado para el commit
nombre_repositorio = f"{hyperparameters['model_name_or_path'].split('/')[1]}-{hyperparameters['dataset_name']}" # nombre del repositorio en huggingface.co
contraseña = getpass("Ingresa tu contraseña:") # crea un cuadro de diálogo para ingresar la contraseña

# obtener el token de hf
token = HfApi().login(username=hf_username, password=contraseña)

# crear repositorio
repo_url = HfApi().create_repo(token=token, name=nombre_repositorio, exist_ok=True)

# crear una instancia de Repository
modelo_repo = Repository(use_auth_token=token,
                        clone_from=repo_url,
                        local_dir=local_path,
                        git_user=hf_username,
                        git_email=hf_email)

# subir el modelo al hub
modelo_repo.push_to_hub()

---

Probar inferencia

Después de subir nuestro modelo, podemos acceder a él en https://huggingface.co/{hf_username}/{nombre_repositorio}

print(f"https://huggingface.co/{hf_username}/{nombre_repositorio}")

Y utilizar el widget “Hosted Inference API” para probarlo.

https://huggingface.co/philschmid/bart-large-cnn-samsum

We will continue to update Zepes; if you have any questions or suggestions, please contact us!