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.

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!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Inteligencia Artificial

Deci presenta DeciCoder un modelo de lenguaje grande de c贸digo abierto con 1 bill贸n de par谩metros para generaci贸n de c贸digo.

En el mundo acelerado de la IA, la generaci贸n eficiente de c贸digo es un desaf铆o que no se puede pasar por alto. Con l...

Inteligencia Artificial

Visi贸n a trav茅s del sonido para los ciegos

Los cient铆ficos han creado tecnolog铆a de toque ac煤stico que utiliza el sonido para ayudar a las personas ciegas a ver.

Noticias de Inteligencia Artificial

Robot utiliza una frambuesa falsa para practicar la recolecci贸n de frutas.

Los cient铆ficos dise帽aron un robot que practic贸 la recolecci贸n de frambuesas en una r茅plica de frambuesa de silicona ...