Ajuste e implemente un modelo de resúmenes utilizando los contenedores Hugging Face de Amazon SageMaker con su propia secuencia de comandos.

Ha habido muchos avances recientes en el dominio de la PNL. Los modelos preentrenados y los servicios de PNL completamente administrados han democratizado el acceso y la adopción de la PNL. Amazon Comprehend es un servicio totalmente administrado que puede realizar tareas de NLP como el reconocimiento de entidades personalizadas, el modelado de temas, el análisis de sentimientos y más para extraer información de los datos sin necesidad de experiencia previa en ML.

El año pasado, AWS anunció una asociación Abrazando la cara para ayudar a que los modelos de procesamiento de lenguaje natural (NLP) entren en producción más rápido. Hugging Face es una comunidad de IA de código abierto, centrada en la PNL. Su biblioteca basada en Python (Transformers) proporciona herramientas para usar fácilmente arquitecturas populares de Transformer de última generación como BERT, RoBERTa y GPT. Puede aplicar estos modelos a una variedad de tareas de NLP, como clasificación de texto, extracción de información y respuesta a preguntas, entre otros.

Amazon SageMaker es un servicio completamente administrado que brinda a los desarrolladores y científicos de datos la capacidad de crear, entrenar e implementar modelos de aprendizaje automático (ML) rápidamente. SageMaker elimina el trabajo pesado de cada paso del proceso de ML, lo que facilita el desarrollo de modelos de alta calidad. El SDK de Python de SageMaker proporciona API y contenedores de código abierto para entrenar e implementar modelos en SageMaker, utilizando varios marcos de aprendizaje profundo y aprendizaje automático diferentes.

La integración de Hugging Face con SageMaker le permite crear modelos de Hugging Face a escala en sus propios casos de uso específicos de dominio.

En esta publicación, lo guiaremos a través de un ejemplo de cómo crear e implementar un resumen de texto personalizado de Hugging Face en SageMaker. Usamos Pegasus [1] para este propósito, el primer modelo basado en Transformer específicamente entrenado previamente en un objetivo diseñado para el resumen de texto abstracto. BERT está previamente capacitado para enmascarar palabras aleatorias en una oración; por el contrario, durante el entrenamiento previo de Pegasus, las oraciones se enmascaran de un documento de entrada. Luego, el modelo genera las oraciones que faltan como una sola secuencia de salida usando todas las oraciones sin enmascarar como contexto, creando como resultado un resumen ejecutivo del documento.

Gracias a la flexibilidad de la biblioteca HuggingFace, puede adaptar fácilmente el código que se muestra en esta publicación para otros tipos de modelos de transformadores, como t5, BART y más.

Cargue su propio conjunto de datos para ajustar un modelo Hugging Face

Para cargar un conjunto de datos personalizado desde un archivo CSV, usamos el load_dataset método del paquete Transformers. Podemos aplicar la tokenización al conjunto de datos cargado usando el datasets.Dataset.map función. los map itera sobre el conjunto de datos cargado y aplica la función tokenize a cada ejemplo. Luego, el conjunto de datos tokenizado se puede pasar al entrenador para ajustar el modelo. Ver el siguiente código:

# Python
def tokenize(batch):
    tokenized_input = tokenizer(batch[args.input_column], padding='max_length', truncation=True, max_length=args.max_source)
    tokenized_target = tokenizer(batch[args.target_column], padding='max_length', truncation=True, max_length=args.max_target)
    tokenized_input['target'] = tokenized_target['input_ids']

    return tokenized_input
    

def load_and_tokenize_dataset(data_dir):
    for file in os.listdir(data_dir):
        dataset = load_dataset("csv", data_files=os.path.join(data_dir, file), split='train')
    tokenized_dataset = dataset.map(lambda batch: tokenize(batch), batched=True, batch_size=512)
    tokenized_dataset.set_format('numpy', columns=['input_ids', 'attention_mask', 'labels'])
    
    return tokenized_dataset

Cree su guión de entrenamiento para el estimador Hugging Face SageMaker

Como se explica en la publicación. AWS y Hugging Face colaboran para simplificar y acelerar la adopción de modelos de procesamiento de lenguaje natural, capacitar a un modelo Hugging Face en SageMaker nunca ha sido tan fácil. Podemos hacerlo usando el estimador Hugging Face de la SDK de SageMaker.

El siguiente fragmento de código ajusta Pegasus en nuestro conjunto de datos. También puedes encontrar muchos cuadernos de muestra que lo guían a través del ajuste fino de diferentes tipos de modelos, disponibles directamente en el repositorio de Transformers GitHub. Para habilitar el entrenamiento distribuido, podemos usar el Biblioteca de paralelismo de datos en SageMaker, que se ha integrado en la API HuggingFace Trainer. Para habilitar el paralelismo de datos, necesitamos definir el distribution parámetro en nuestro estimador Hugging Face.

# Python
from sagemaker.huggingface import HuggingFace
# configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}
huggingface_estimator = HuggingFace(entry_point='train.py',
                                    source_dir='code',
                                    base_job_name='huggingface-pegasus',
                                    instance_type= 'ml.g4dn.16xlarge',
                                    instance_count=1,
                                    transformers_version='4.6',
                                    pytorch_version='1.7',
                                    py_version='py36',
                                    output_path=output_path,
                                    role=role,
                                    hyperparameters = {
                                        'model_name': 'google/pegasus-xsum',
                                        'epoch': 10,
                                        'per_device_train_batch_size': 2
                                    },
                                    distribution=distribution)
huggingface_estimator.fit({'train': training_input_path, 'validation': validation_input_path, 'test': test_input_path})

El tamaño máximo del lote de entrenamiento que puede configurar depende del tamaño del modelo y la memoria de GPU de la instancia utilizada. Si la capacitación distribuida de SageMaker está habilitada, el tamaño total del lote es la suma de cada lote que se distribuye en cada dispositivo/GPU. Si usamos una instancia ml.g4dn.16xlarge con entrenamiento distribuido en lugar de una instancia ml.g4dn.xlarge, tenemos ocho veces (8 GPU) más memoria que una instancia ml.g4dn.xlarge (1 GPU). El tamaño del lote por dispositivo sigue siendo el mismo, pero se están capacitando ocho dispositivos en paralelo.

Como es habitual con SageMaker, creamos un train.py secuencia de comandos para usar con el modo de secuencia de comandos y pasar hiperparámetros para el entrenamiento. El siguiente fragmento de código para Pegasus carga el modelo y lo entrena usando Transformers Trainer clase:

# Python
from transformers import (
    AutoModelForSeq2SeqLM,
    AutoTokenizer,
    Seq2SeqTrainer,
    Seq2seqTrainingArguments
)

model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)
    
training_args = Seq2seqTrainingArguments(
    output_dir=args.model_dir,
    num_train_epochs=args.epoch,
    per_device_train_batch_size=args.train_batch_size,
    per_device_eval_batch_size=args.eval_batch_size,
    warmup_steps=args.warmup_steps,
    weight_decay=args.weight_decay,
    logging_dir=f"{args.output_data_dir}/logs",
    logging_strategy='epoch',
    evaluation_strategy='epoch',
    saving_strategy='epoch',
    adafactor=True,
    do_train=True,
    do_eval=True,
    do_predict=True,
    save_total_limit = 3,
    load_best_model_at_end=True,
    metric_for_best_model='eval_loss'
    # With the goal to deploy the best checkpoint to production
    # it is important to set load_best_model_at_end=True,
    # this makes sure that the last model is saved at the root
    # of the model_dir” directory
)
    
trainer = Seq2SeqTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset['train'],
    eval_dataset=dataset['validation']
)

trainer.train()
trainer.save_model()

# Get rid of unused checkpoints inside the container to limit the model.tar.gz size
os.system(f"rm -rf {args.model_dir}/checkpoint-*/")

El código completo está disponible en GitHub.

Implemente el modelo de cara abrazada capacitado en SageMaker

Nuestros amigos de Hugging Face han simplificado más que nunca la inferencia en SageMaker para los modelos de Transformers gracias a la Kit de herramientas de inferencia de cara abrazada de SageMaker. Puede implementar directamente el modelo previamente entrenado simplemente configurando la variable de entorno "HF_TASK":"summarization" (para obtener instrucciones, consulte Modelos Pegasus), eligiendo Despliegue, y luego eligiendo Amazon SageMaker, sin necesidad de escribir un script de inferencia.

Sin embargo, si necesita alguna forma específica de generar o posprocesar predicciones, por ejemplo, generar varias sugerencias de resumen basadas en una lista de diferentes parámetros de generación de texto, escribir su propio script de inferencia puede ser útil y relativamente sencillo:

# Python
# inference.py script

import os
import json
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

def model_fn(model_dir):
    # Create the model and tokenizer and load weights
    # from the previous training Job, passed here through "model_dir"
    # that is reflected in HuggingFaceModel "model_data"
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_dir).to(device).eval()
    
    model_dict = {'model':model, 'tokenizer':tokenizer}
    
    return model_dict
        

def predict_fn(input_data, model_dict):
    # Return predictions/generated summaries
    # using the loaded model and tokenizer on input_data
    text = input_data.pop('inputs')
    parameters_list = input_data.pop('parameters_list', None)
    
    tokenizer = model_dict['tokenizer']
    model = model_dict['model']

    # Parameters may or may not be passed    
    input_ids = tokenizer(text, truncation=True, padding='longest', return_tensors="pt").input_ids.to(device)
    
    if parameters_list:
        predictions = []
        for parameters in parameters_list:
            output = model.generate(input_ids, **parameters)
            predictions.append(tokenizer.batch_decode(output, skip_special_tokens=True))
    else:
        output = model.generate(input_ids)
        predictions = tokenizer.batch_decode(output, skip_special_tokens=True)
    
    return predictions
    
    
def input_fn(request_body, request_content_type):
    # Transform the input request to a dictionary
    request = json.loads(request_body)
    return request

Como se muestra en el código anterior, una secuencia de comandos de inferencia de este tipo para HuggingFace en SageMaker solo necesita las siguientes funciones de plantilla:

• model_fn () – Lee el contenido de lo que se guardó al final del trabajo de entrenamiento en el interior SM_MODEL_DIR, o desde un directorio de pesos de modelo existente guardado como un archivo tar.gz en Servicio de almacenamiento simple de Amazon (Amazon S3). Se usa para cargar el modelo entrenado y el tokenizador asociado.
• input_fn () – Formatea los datos recibidos de una solicitud realizada al punto final.
• predic_fn () – Llama la salida de model_fn() (el modelo y tokenizador) para ejecutar la inferencia en la salida de input_fn() (los datos formateados).

Opcionalmente, puede crear un output_fn() función para el formato de inferencia, utilizando la salida de predict_fn(), que no demostramos en esta publicación.

Luego, podemos implementar el modelo Hugging Face entrenado con su script de inferencia asociado en SageMaker usando el Modelo de SageMaker de cara abrazada clase:

# Python
from sagemaker.huggingface import HuggingFaceModel

model = HuggingFaceModel(model_data=huggingface_estimator.model_data,
                     role=role,
                     framework_version='1.7',
                     py_version='py36',
                     entry_point='inference.py',
                     source_dir='code')
                     
predictor = model.deploy(initial_instance_count=1,
                         instance_type='ml.g4dn.xlarge'
                         )

Probar el modelo desplegado

Para esta demostración, entrenamos al modelo en el Conjunto de datos de reseñas de ropa de comercio electrónico para mujeres, que contiene reseñas de prendas de vestir (que consideramos como texto de entrada) y sus títulos asociados (que consideramos como resúmenes). Después de eliminar los artículos a los que les faltan títulos, el conjunto de datos contiene 19,675 70 reseñas. Ajustar el modelo de Pegasus en un conjunto de entrenamiento que contenía el 3.5 % de esos artículos durante cinco épocas llevó aproximadamente 3.16 horas en una instancia ml.pXNUMXxlarge.

Luego podemos implementar el modelo y probarlo con algunos datos de ejemplo del conjunto de prueba. El siguiente es un ejemplo de revisión que describe un suéter:

# Python
Review Text
"I ordered this sweater in green in petite large. The color and knit is beautiful and the shoulders and body fit comfortably; however, the sleeves were very long for a petite. I roll them, and it looks okay but would have rather had a normal petite length sleeve."

Original Title
"Long sleeves"

Rating
3

Gracias a nuestro script de inferencia personalizado alojado en un punto final de SageMaker, podemos generar varios resúmenes para esta revisión con diferentes parámetros de generación de texto. Por ejemplo, podemos pedirle al punto final que genere un rango de resúmenes muy cortos a moderadamente largos que especifiquen diferentes penalizaciones de longitud (cuanto menor sea la penalización de longitud, más corto será el resumen generado). Los siguientes son algunos ejemplos de entrada de parámetros y los subsiguientes resúmenes generados por máquinas:

# Python
inputs = {
    "inputs":[
"I ordered this sweater in green in petite large. The color and knit is   beautiful and the shoulders and body fit comfortably; however, the sleeves were very long for a petite. I roll them, and it looks okay but would have rather had a normal petite length sleeve."
    ],

    "parameters_list":[
        {
            "length_penalty":2
        },
	{
            "length_penalty":1
        },
	{
            "length_penalty":0.6
        },
        {
            "length_penalty":0.4
        }
    ]

result = predictor.predict(inputs)
print(result)

[
    ["Beautiful color and knit but sleeves are very long for a petite"],
    ["Beautiful sweater, but sleeves are too long for a petite"],
    ["Cute, but sleeves are long"],
    ["Very long sleeves"]
]

¿Qué resumen prefieres? El primer título generado captura todos los hechos importantes sobre la reseña, con una cuarta parte del número de palabras. En contraste, el último solo usa tres palabras (menos de 1/10 de la extensión de la reseña original) para enfocarse en la característica más importante del suéter.

Conclusión

Puede ajustar un resumen de texto en su conjunto de datos personalizado e implementarlo en producción en SageMaker con este sencillo ejemplo disponible en GitHub. Adicional cuadernos de muestra para entrenar e implementar modelos Hugging Face en SageMaker también están disponibles.

Como siempre, AWS agradece sus comentarios. Envíe sus comentarios o preguntas.

Referencias

[1] PEGASUS: Pre-entrenamiento con oraciones en hueco extraídas para resúmenes abstractivos

Sobre los autores

Viktor Malesevic es un ingeniero de aprendizaje automático de AWS Professional Services, apasionado por el procesamiento del lenguaje natural y MLOps. Trabaja con los clientes para desarrollar y poner en producción modelos desafiantes de aprendizaje profundo en AWS. En su tiempo libre, disfruta compartir una copa de vino tinto y un poco de queso con amigos.

Aamna Najmi es un científico de datos con los servicios profesionales de AWS. Le apasiona ayudar a los clientes a innovar con tecnologías de Big Data e Inteligencia Artificial para aprovechar el valor comercial y los conocimientos de los datos. En su tiempo libre, disfruta de la jardinería y de viajar a nuevos lugares.