Ajustez et déployez un modèle de synthèse à l'aide des conteneurs Amazon SageMaker Hugging Face en apportant votre propre script

Il y a eu de nombreuses avancées récentes dans le domaine de la PNL. Des modèles préformés et des services de PNL entièrement gérés ont démocratisé l'accès et l'adoption de la PNL. Amazon comprendre est un service entièrement géré qui peut effectuer des tâches NLP telles que la reconnaissance d'entités personnalisées, la modélisation de sujets, l'analyse des sentiments et plus encore pour extraire des informations à partir de données sans avoir besoin d'une expérience préalable en ML.

L'année dernière, AWS a annoncé un partenariat comprenant Étreindre le visage pour accélérer la mise en production des modèles de traitement du langage naturel (TAL). Hugging Face est une communauté d'IA open source, axée sur la PNL. Leur bibliothèque basée sur Python (Transformateurs) fournit des outils pour utiliser facilement les architectures Transformer de pointe populaires telles que BERT, RoBERTa et GPT. Vous pouvez appliquer ces modèles à une variété de tâches NLP, telles que la classification de texte, l'extraction d'informations et la réponse aux questions, parmi autres.

Amazon Sage Maker est un service entièrement géré qui offre aux développeurs et aux spécialistes des données la possibilité de créer, de former et de déployer rapidement des modèles d'apprentissage automatique (ML). SageMaker supprime les tâches lourdes de chaque étape du processus ML, ce qui facilite le développement de modèles de haute qualité. Le SDK Python SageMaker fournit des API et des conteneurs open source pour former et déployer des modèles sur SageMaker, à l'aide de plusieurs frameworks ML et d'apprentissage en profondeur différents.

L'intégration de Hugging Face avec SageMaker vous permet de créer des modèles de Hugging Face à grande échelle sur vos propres cas d'utilisation spécifiques à votre domaine.

Dans cet article, nous vous expliquons comment créer et déployer un résumé de texte personnalisé Hugging Face sur SageMaker. Nous utilisons Pegasus [1] à cette fin, le premier modèle basé sur Transformer spécifiquement pré-entraîné sur un objectif adapté au résumé de texte abstrait. BERT est pré-formé pour masquer des mots aléatoires dans une phrase; en revanche, pendant la pré-formation de Pegasus, les phrases sont masquées à partir d'un document d'entrée. Le modèle génère ensuite les phrases manquantes sous la forme d'une séquence de sortie unique en utilisant toutes les phrases non masquées comme contexte, créant ainsi un résumé exécutif du document.

Grâce à la flexibilité de la bibliothèque HuggingFace, vous pouvez facilement adapter le code présenté dans cet article à d'autres types de modèles de transformateurs, tels que t5, BART, etc.

Chargez votre propre ensemble de données pour affiner un modèle Hugging Face

Pour charger un ensemble de données personnalisé à partir d'un fichier CSV, nous utilisons le load_dataset méthode du package Transformers. Nous pouvons appliquer la tokenisation à l'ensemble de données chargé en utilisant le datasets.Dataset.map fonction. le map La fonction effectue une itération sur l'ensemble de données chargé et applique la fonction tokenize à chaque exemple. L'ensemble de données tokenisé peut ensuite être transmis au formateur pour affiner le modèle. Voir le code suivant :

# 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

Créez votre script de formation pour l'estimateur Hugging Face SageMaker

Comme expliqué dans le post AWS et Hugging Face collaborent pour simplifier et accélérer l'adoption des modèles de traitement du langage naturel, former un modèle Hugging Face sur SageMaker n'a jamais été aussi facile. Nous pouvons le faire en utilisant l'estimateur Hugging Face du SDK SageMaker.

L'extrait de code suivant affine Pegasus sur notre ensemble de données. Vous pouvez également trouver de nombreux exemples de cahiers qui vous guident dans le réglage fin de différents types de modèles, disponibles directement dans le référentiel GitHub des transformateurs. Pour activer la formation distribuée, nous pouvons utiliser le Bibliothèque de parallélisme des données dans SageMaker, qui a été intégré à l'API HuggingFace Trainer. Pour activer le parallélisme des données, nous devons définir le distribution paramètre dans notre estimateur de visage étreignant.

# 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})

La taille de lot d'entraînement maximale que vous pouvez configurer dépend de la taille du modèle et de la mémoire GPU de l'instance utilisée. Si la formation distribuée SageMaker est activée, la taille totale du lot est la somme de chaque lot distribué sur chaque appareil/GPU. Si nous utilisons un ml.g4dn.16xlarge avec entraînement distribué au lieu d'une instance ml.g4dn.xlarge, nous avons huit fois (8 GPU) plus de mémoire qu'une instance ml.g4dn.xlarge (1 GPU). La taille du lot par appareil reste la même, mais huit appareils s'entraînent en parallèle.

Comme d'habitude avec SageMaker, nous créons un train.py script à utiliser avec le mode Script et transmettre des hyperparamètres pour la formation. L'extrait de code suivant pour Pegasus charge le modèle et l'entraîne à l'aide des transformateurs Trainer classe:

# 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-*/")

Le code complet est disponible sur GitHub.

Déployer le modèle Hugging Face formé sur SageMaker

Nos amis de Hugging Face ont rendu l'inférence sur les modèles SageMaker pour Transformers plus simple que jamais grâce à la Boîte à outils d'inférence de visage étreignant SageMaker. Vous pouvez déployer directement le modèle précédemment formé en configurant simplement la variable d'environnement "HF_TASK":"summarization" (pour les instructions, voir Modèles Pegasus), en choisissant Déployer, puis en choisissant Amazon Sage Maker, sans avoir besoin d'écrire un script d'inférence.

Cependant, si vous avez besoin d'un moyen spécifique pour générer ou post-traiter des prédictions, par exemple en générant plusieurs suggestions récapitulatives basées sur une liste de différents paramètres de génération de texte, écrire votre propre script d'inférence peut être utile et relativement simple :

# 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

Comme indiqué dans le code précédent, un tel script d'inférence pour HuggingFace sur SageMaker n'a besoin que des fonctions de modèle suivantes :

• modèle_fn() – Lit le contenu de ce qui a été enregistré à la fin du travail de formation à l'intérieur SM_MODEL_DIR, ou à partir d'un répertoire de poids de modèle existant enregistré en tant que fichier tar.gz dans Service de stockage simple Amazon (Amazon S3). Il est utilisé pour charger le modèle formé et le tokenizer associé.
• input_fn () – Formate les données reçues d'une demande faite au point de terminaison.
• prédire_fn () – Appelle la sortie de model_fn() (le modèle et le tokenizer) pour exécuter l'inférence sur la sortie de input_fn() (les données formatées).

En option, vous pouvez créer un output_fn() fonction pour le formatage d'inférence, en utilisant la sortie de predict_fn(), ce que nous n'avons pas démontré dans cet article.

Nous pouvons ensuite déployer le modèle Hugging Face formé avec son script d'inférence associé sur SageMaker en utilisant le Modèle SageMaker étreignant le visage classe:

# 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'
                         )

Tester le modèle déployé

Pour cette démo, nous avons formé le modèle sur le Ensemble de données Avis sur les vêtements de commerce électronique pour femmes, qui contient des critiques d'articles vestimentaires (que nous considérons comme le texte d'entrée) et leurs titres associés (que nous considérons comme des résumés). Une fois que nous avons supprimé les articles avec des titres manquants, l'ensemble de données contient 19,675 70 avis. Le réglage fin du modèle Pegasus sur un ensemble d'entraînement contenant 3.5 % de ces articles pour cinq époques a pris environ 3.16 heures sur une instance ml.pXNUMXxlarge.

Nous pouvons ensuite déployer le modèle et le tester avec quelques exemples de données de l'ensemble de test. Voici un exemple d'avis décrivant un pull :

# 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

Grâce à notre script d'inférence personnalisé hébergé dans un point de terminaison SageMaker, nous pouvons générer plusieurs résumés pour cette revue avec différents paramètres de génération de texte. Par exemple, nous pouvons demander au point de terminaison de générer une gamme de résumés très courts à modérément longs spécifiant différentes pénalités de longueur (plus la pénalité de longueur est petite, plus le résumé généré est court). Voici quelques exemples de saisie de paramètres et les récapitulatifs générés par la machine suivants :

# 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"]
]

Quel résumé préférez-vous ? Le premier titre généré capture tous les faits importants de la revue, avec un quart du nombre de mots. En revanche, le dernier n'utilise que trois mots (moins de 1/10e de la longueur de la critique originale) pour se concentrer sur la caractéristique la plus importante du pull.

Conclusion

Vous pouvez affiner un résumé de texte sur votre jeu de données personnalisé et le déployer en production sur SageMaker avec cet exemple simple disponible sur GitHub. Additionnel exemples de cahiers pour former et déployer des modèles Hugging Face sur SageMaker sont également disponibles.

Comme toujours, AWS apprécie les commentaires. Veuillez soumettre vos commentaires ou questions.

Bibliographie

[1] PEGASUS : Pré-formation avec des phrases Gap extraites pour le résumé abstrait

À propos des auteurs

Viktor Malesević est un ingénieur en apprentissage automatique chez AWS Professional Services, passionné par le traitement du langage naturel et les MLOps. Il travaille avec les clients pour développer et mettre en production des modèles d'apprentissage en profondeur stimulants sur AWS. Dans ses temps libres, il aime partager un verre de vin rouge et du fromage avec des amis.

Aamna Najmi est un Data Scientist avec AWS Professional Services. Elle est passionnée d'aider les clients à innover avec les technologies Big Data et Intelligence Artificielle pour exploiter la valeur commerciale et les informations à partir des données. Dans ses temps libres, elle aime jardiner et voyager dans de nouveaux endroits.