Optimieren und implementieren Sie ein Zusammenfassungsmodell mithilfe der Hugging Face Amazon SageMaker-Container, die Ihr eigenes Skript mitbringen

Im NLP-Bereich hat es in letzter Zeit viele Fortschritte gegeben. Vortrainierte Modelle und vollständig verwaltete NLP-Dienste haben den Zugang und die Akzeptanz von NLP demokratisiert. Amazon verstehen ist ein vollständig verwalteter Dienst, der NLP-Aufgaben wie benutzerdefinierte Entitätserkennung, Themenmodellierung, Stimmungsanalyse und mehr ausführen kann, um Erkenntnisse aus Daten zu extrahieren, ohne dass vorherige ML-Erfahrung erforderlich ist.

Letztes Jahr kündigte AWS a Partnerschaft mit Gesicht umarmen um Modelle zur Verarbeitung natürlicher Sprache (NLP) schneller in die Produktion zu bringen. Hugging Face ist eine Open-Source-KI-Community, die sich auf NLP konzentriert. Ihre Python-basierte Bibliothek (Transformatoren) bietet Tools zur einfachen Verwendung beliebter, hochmoderner Transformer-Architekturen wie BERT, RoBERTa und GPT. Sie können diese Modelle auf eine Vielzahl von NLP-Aufgaben anwenden, darunter Textklassifizierung, Informationsextraktion und Fragenbeantwortung Extras.

Amazon Sage Maker ist ein vollständig verwalteter Dienst, der Entwicklern und Datenwissenschaftlern die Möglichkeit bietet, Modelle für maschinelles Lernen (ML) schnell zu erstellen, zu trainieren und bereitzustellen. SageMaker entfernt die schwere Arbeit aus jedem Schritt des ML-Prozesses und erleichtert so die Entwicklung hochwertiger Modelle. Das SageMaker Python SDK bietet Open-Source-APIs und -Container zum Trainieren und Bereitstellen von Modellen auf SageMaker unter Verwendung mehrerer verschiedener ML- und Deep-Learning-Frameworks.

Die Hugging Face-Integration mit SageMaker ermöglicht es Ihnen, Hugging Face-Modelle in großem Maßstab für Ihre eigenen domänenspezifischen Anwendungsfälle zu erstellen.

In diesem Beitrag führen wir Sie durch ein Beispiel für die Erstellung und Bereitstellung einer benutzerdefinierten Hugging Face-Textzusammenfassung in SageMaker. Zu diesem Zweck verwenden wir Pegasus [1], das erste Transformer-basierte Modell, das speziell auf ein Ziel vortrainiert wurde, das auf die Zusammenfassung abstrakter Texte zugeschnitten ist. BERT ist darauf trainiert, zufällige Wörter in einem Satz zu maskieren; Im Gegensatz dazu werden während des Vortrainings von Pegasus Sätze aus einem Eingabedokument maskiert. Das Modell generiert dann die fehlenden Sätze als einzelne Ausgabesequenz, wobei alle unmaskierten Sätze als Kontext verwendet werden, und erstellt als Ergebnis eine Zusammenfassung des Dokuments.

Dank der Flexibilität der HuggingFace-Bibliothek können Sie den in diesem Beitrag gezeigten Code problemlos für andere Arten von Transformatormodellen wie t5, BART und mehr anpassen.

Laden Sie Ihren eigenen Datensatz, um ein Hugging Face-Modell zu optimieren

Um einen benutzerdefinierten Datensatz aus einer CSV-Datei zu laden, verwenden wir die load_dataset Methode aus dem Transformers-Paket. Wir können die Tokenisierung auf das geladene Dataset anwenden, indem wir die verwenden datasets.Dataset.map Funktion. Das map Die Funktion iteriert über das geladene Dataset und wendet die Tokenisierungsfunktion auf jedes Beispiel an. Der tokenisierte Datensatz kann dann zur Feinabstimmung des Modells an den Trainer weitergegeben werden. Siehe folgenden Code:

# 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

Erstellen Sie Ihr Trainingsskript für den Hugging Face SageMaker-Schätzer

Wie im Beitrag erklärt AWS und Hugging Face arbeiten zusammen, um die Einführung von Natural Language Processing-Modellen zu vereinfachen und zu beschleunigen, das Trainieren eines Hugging Face-Modells auf SageMaker war noch nie so einfach. Wir können dies tun, indem wir den Hugging Face-Schätzer von verwenden SageMaker-SDK.

Das folgende Code-Snippet verfeinert Pegasus auf unserem Datensatz. Sie können auch viele finden Beispielnotizbücher die Sie durch die Feinabstimmung verschiedener Arten von Modellen führen, die direkt im GitHub-Repository von Transformers verfügbar sind. Um verteiltes Training zu ermöglichen, können wir die verwenden Bibliothek für Datenparallelität in SageMaker, das in die HuggingFace Trainer API integriert wurde. Um Datenparallelität zu ermöglichen, müssen wir die definieren distribution Parameter in unserem Hugging Face Schätzer.

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

Die maximale Trainingsbatchgröße, die Sie konfigurieren können, hängt von der Modellgröße und dem GPU-Speicher der verwendeten Instanz ab. Wenn das verteilte Training von SageMaker aktiviert ist, ist die Gesamtbatchgröße die Summe aller Batches, die auf jedes Gerät/GPU verteilt werden. Wenn wir anstelle einer ml.g4dn.xlarge-Instanz eine ml.g16dn.4xlarge mit verteiltem Training verwenden, haben wir achtmal (8 GPUs) so viel Arbeitsspeicher wie eine ml.g4dn.xlarge-Instanz (1 GPU). Die Batchgröße pro Gerät bleibt gleich, aber acht Geräte trainieren parallel.

Wie bei SageMaker üblich, erstellen wir eine train.py Skript zur Verwendung mit dem Skriptmodus und zum Übergeben von Hyperparametern für das Training. Das folgende Code-Snippet für Pegasus lädt das Modell und trainiert es mit den Transformers Trainer Klasse:

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

Den vollständigen Code finden Sie unter GitHub.

Stellen Sie das trainierte Hugging Face-Modell in SageMaker bereit

Unsere Freunde bei Hugging Face haben die Rückschlüsse auf SageMaker für Transformers-Modelle dank der einfacher als je zuvor gemacht SageMaker Hugging Face Inference Toolkit. Sie können das zuvor trainierte Modell direkt bereitstellen, indem Sie einfach die Umgebungsvariable einrichten "HF_TASK":"summarization" (Anleitung siehe Pegasus-Modelle), auswählen Deploy, und dann auswählen Amazon Sage Maker, ohne dass ein Inferenzskript geschrieben werden muss.

Wenn Sie jedoch eine bestimmte Methode zum Generieren oder Nachbearbeiten von Vorhersagen benötigen, z. B. das Generieren mehrerer zusammenfassender Vorschläge basierend auf einer Liste verschiedener Textgenerierungsparameter, kann das Schreiben eines eigenen Inferenzskripts nützlich und relativ einfach sein:

# 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

Wie im vorherigen Code gezeigt, benötigt ein solches Inferenzskript für HuggingFace auf SageMaker nur die folgenden Vorlagenfunktionen:

• model_fn () – Liest den Inhalt dessen aus, was am Ende des Trainingsjobs im Inneren gespeichert wurde SM_MODEL_DIR, oder aus einem vorhandenen Modellgewichtsverzeichnis, das als tar.gz-Datei in gespeichert ist Amazon Simple Storage-Service (Amazon S3). Es wird verwendet, um das trainierte Modell und den zugehörigen Tokenizer zu laden.
• input_fn () – Formatiert die Daten, die von einer Anfrage an den Endpunkt empfangen werden.
• Predict_FN () – Ruft die Ausgabe von auf model_fn() (das Modell und der Tokenizer), um die Inferenz auf die Ausgabe von auszuführen input_fn() (die formatierten Daten).

Optional können Sie eine erstellen output_fn() Funktion für die Inferenzformatierung unter Verwendung der Ausgabe von predict_fn(), die wir in diesem Beitrag nicht demonstriert haben.

Wir können dann das trainierte Hugging Face-Modell mit dem zugehörigen Inferenzskript für SageMaker bereitstellen, indem wir die verwenden Umarmendes Gesicht SageMaker-Modell Klasse:

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

Testen Sie das bereitgestellte Modell

Für diese Demo haben wir das Modell auf dem trainiert E-Commerce-Bekleidungsbewertungs-Datensatz für Damen, das Bewertungen von Bekleidungsartikeln (die wir als Eingabetext betrachten) und die zugehörigen Titel (die wir als Zusammenfassungen betrachten) enthält. Nachdem wir Artikel mit fehlenden Titeln entfernt haben, enthält der Datensatz 19,675 Rezensionen. Die Feinabstimmung des Pegasus-Modells auf einem Trainingsset, das 70 % dieser Artikel für fünf Epochen enthielt, dauerte auf einer ml.p3.5xlarge-Instanz ungefähr 3.16 Stunden.

Anschließend können wir das Modell bereitstellen und mit einigen Beispieldaten aus dem Testset testen. Das Folgende ist eine Beispielbewertung, die einen Pullover beschreibt:

# 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

Dank unseres benutzerdefinierten Inferenzskripts, das in einem SageMaker-Endpunkt gehostet wird, können wir mehrere Zusammenfassungen für diese Überprüfung mit unterschiedlichen Textgenerierungsparametern erstellen. Beispielsweise können wir den Endpunkt bitten, eine Reihe von sehr kurzen bis mäßig langen Zusammenfassungen zu generieren, die unterschiedliche Längenstrafen angeben (je kleiner die Längenstrafe, desto kürzer die generierte Zusammenfassung). Im Folgenden finden Sie einige Beispiele für Parametereingaben und die anschließenden maschinell erstellten Zusammenfassungen:

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

Welche Zusammenfassung bevorzugen Sie? Der erste generierte Titel erfasst alle wichtigen Fakten zur Rezension mit einem Viertel der Wortzahl. Im Gegensatz dazu verwendet die letzte nur drei Wörter (weniger als 1/10 der Länge der ursprünglichen Rezension), um sich auf das wichtigste Merkmal des Pullovers zu konzentrieren.

Zusammenfassung

Mit diesem einfachen Beispiel, das unter verfügbar ist, können Sie eine Textzusammenfassung für Ihr benutzerdefiniertes Dataset optimieren und für die Produktion auf SageMaker bereitstellen GitHub. Zusätzlich Beispielnotizbücher zum Trainieren und Bereitstellen von Hugging Face-Modellen auf SageMaker sind ebenfalls verfügbar.

Wie immer freut sich AWS über Feedback. Bitte senden Sie Kommentare oder Fragen.

Bibliographie

[1] PEGASUS: Vortraining mit extrahierten Lückensätzen für die abstrakte Zusammenfassung

Über die Autoren

Viktor Malešević ist Machine Learning Engineer bei AWS Professional Services und hat eine Leidenschaft für Natural Language Processing und MLOps. Er arbeitet mit Kunden zusammen, um anspruchsvolle Deep-Learning-Modelle zu entwickeln und auf AWS in Produktion zu bringen. In seiner Freizeit genießt er es, mit Freunden ein Glas Rotwein und etwas Käse zu trinken.

Aamna Najmi ist Data Scientist bei AWS Professional Services. Sie ist leidenschaftlich daran interessiert, Kunden bei der Innovation mit Big Data und Technologien der künstlichen Intelligenz zu unterstützen, um Geschäftswert und Erkenntnisse aus Daten zu erschließen. In ihrer Freizeit arbeitet sie gerne im Garten und bereist neue Orte.