Verfijn en implementeer een samenvattingsmodel met behulp van de Hugging Face Amazon SageMaker-containers met uw eigen script

Er zijn veel recente ontwikkelingen geweest in het NLP-domein. Vooraf getrainde modellen en volledig beheerde NLP-services hebben de toegang tot en acceptatie van NLP gedemocratiseerd. Amazon begrijpt het is een volledig beheerde service die NLP-taken kan uitvoeren, zoals herkenning van aangepaste entiteiten, onderwerpmodellering, sentimentanalyse en meer om inzichten uit gegevens te extraheren zonder voorafgaande ML-ervaring.

Vorig jaar kondigde AWS een vennootschap Met Gezicht knuffelen om modellen voor natuurlijke taalverwerking (NLP) sneller in productie te brengen. Hugging Face is een open-source AI-community, gericht op NLP. Hun op Python gebaseerde bibliotheek (transformers) biedt tools om eenvoudig populaire, ultramoderne Transformer-architecturen zoals BERT, RoBERTa en GPT te gebruiken. U kunt deze modellen toepassen op verschillende NLP-taken, zoals tekstclassificatie, informatie-extractie en het beantwoorden van vragen anderen.

Amazon Sage Maker is een volledig beheerde service die ontwikkelaars en datawetenschappers de mogelijkheid biedt om snel machine learning (ML)-modellen te bouwen, trainen en implementeren. SageMaker haalt het zware werk uit elke stap van het ML-proces, waardoor het gemakkelijker wordt om hoogwaardige modellen te ontwikkelen. De SageMaker Python SDK biedt open-source API's en containers voor het trainen en implementeren van modellen op SageMaker, met behulp van verschillende ML- en deep learning-frameworks.

Dankzij de integratie van Hugging Face met SageMaker kunt u Hugging Face-modellen op schaal bouwen op basis van uw eigen domeinspecifieke gebruiksscenario's.

In dit bericht laten we u een voorbeeld zien van het bouwen en implementeren van een aangepaste Hugging Face-tekstsamenvatting op SageMaker. We gebruiken hiervoor Pegasus [1], het eerste op Transformer gebaseerde model dat specifiek vooraf is getraind op een doelstelling die is afgestemd op abstracte tekstsamenvattingen. BERT is vooraf getraind in het maskeren van willekeurige woorden in een zin; Daarentegen worden tijdens de vooropleiding van Pegasus zinnen gemaskeerd uit een invoerdocument. Het model genereert vervolgens de ontbrekende zinnen als een enkele uitvoerreeks waarbij alle ontmaskerde zinnen als context worden gebruikt, waardoor een samenvatting van het document ontstaat.

Dankzij de flexibiliteit van de HuggingFace-bibliotheek, kun je de code die in dit bericht wordt weergegeven eenvoudig aanpassen voor andere soorten transformatormodellen, zoals t5, BART en meer.

Laad uw eigen dataset om een ​​Hugging Face-model te verfijnen

Om een ​​aangepaste dataset uit een CSV-bestand te laden, gebruiken we de load_dataset methode uit het Transformers-pakket. We kunnen tokenisatie toepassen op de geladen dataset met behulp van de datasets.Dataset.map functie. De map functie herhaalt de geladen dataset en past de tokenize-functie toe op elk voorbeeld. De tokenized dataset kan vervolgens worden doorgegeven aan de trainer voor het verfijnen van het model. Zie de volgende 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

Bouw uw trainingsscript voor de Hugging Face SageMaker-schatter

Zoals uitgelegd in het bericht AWS en Hugging Face werken samen om de acceptatie van Natural Language Processing-modellen te vereenvoudigen en te versnellen, is het trainen van een Hugging Face-model op SageMaker nog nooit zo eenvoudig geweest. We kunnen dit doen met behulp van de Hugging Face-schatter van de SageMaker-SDK.

Het volgende codefragment verfijnt Pegasus op onze dataset. Je kunt er ook veel vinden voorbeeld notitieboekjes die u begeleiden bij het verfijnen van verschillende soorten modellen, die rechtstreeks beschikbaar zijn in de GitHub-repository van Transformers. Om gedistribueerde training mogelijk te maken, kunnen we de Bibliotheek voor gegevensparallellisme in SageMaker, dat is ingebouwd in de HuggingFace Trainer API. Om gegevensparallellisme mogelijk te maken, moeten we de distribution parameter in onze Hugging Face-schatter.

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

De maximale trainingsbatchgrootte die u kunt configureren, is afhankelijk van de modelgrootte en het GPU-geheugen van de gebruikte instantie. Als SageMaker gedistribueerde training is ingeschakeld, is de totale batchgrootte de som van elke batch die is verdeeld over elk apparaat/GPU. Als we een ml.g4dn.16xlarge met gedistribueerde training gebruiken in plaats van een ml.g4dn.xlarge-instantie, hebben we acht keer (8 GPU's) zoveel geheugen als een ml.g4dn.xlarge-instantie (1 GPU). De batchgrootte per apparaat blijft hetzelfde, maar acht apparaten trainen parallel.

Zoals gebruikelijk bij SageMaker, creëren we een train.py script om te gebruiken met de scriptmodus en geef hyperparameters door voor training. Het volgende codefragment voor Pegasus laadt het model en traint het met behulp van de 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-*/")

De volledige code is beschikbaar op GitHub.

Implementeer het getrainde Hugging Face-model in SageMaker

Onze vrienden bij Hugging Face hebben de conclusie over SageMaker for Transformers-modellen eenvoudiger dan ooit gemaakt dankzij de SageMaker Toolkit voor knuffelgezichtsinferentie. U kunt het eerder getrainde model direct implementeren door eenvoudig de omgevingsvariabele in te stellen "HF_TASK":"summarization" (voor instructies, zie Pegasus-modellen), kiezen Implementeren, en dan kiezen Amazon Sage Maker, zonder dat u een inferentiescript hoeft te schrijven.

Als u echter een specifieke manier nodig heeft om voorspellingen te genereren of na te werken, bijvoorbeeld het genereren van verschillende samenvattingssuggesties op basis van een lijst met verschillende tekstgeneratieparameters, kan het schrijven van uw eigen inferentiescript nuttig en relatief eenvoudig zijn:

# 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

Zoals getoond in de voorgaande code, heeft een dergelijk inferentiescript voor HuggingFace op SageMaker alleen de volgende sjabloonfuncties nodig:

• model_fn () – Leest de inhoud van wat er is opgeslagen aan het einde van de trainingstaak binnen SM_MODEL_DIR, of uit een bestaande map met modelgewichten die is opgeslagen als een tar.gz-bestand in Amazon eenvoudige opslagservice (Amazon S3). Het wordt gebruikt om het getrainde model en de bijbehorende tokenizer te laden.
• input_fn () – Formatteert de gegevens die zijn ontvangen van een verzoek aan het eindpunt.
• predict_fn () – Roept de uitvoer van . op model_fn() (het model en de tokenizer) om gevolgtrekkingen uit te voeren op de uitvoer van input_fn() (de opgemaakte gegevens).

Optioneel kunt u een output_fn() functie voor inferentieopmaak, met behulp van de uitvoer van predict_fn(), die we niet hebben aangetoond in dit bericht.

We kunnen dan het getrainde Hugging Face-model met het bijbehorende inferentiescript in SageMaker implementeren met behulp van de Knuffelend gezicht SageMaker-model 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'
                         )

Test het geïmplementeerde model

Voor deze demo hebben we het model getraind op de E-commerce kledingrecensies voor dames, dataset, die recensies bevat van kledingartikelen (die we beschouwen als de invoertekst) en de bijbehorende titels (die we beschouwen als samenvattingen). Nadat we artikelen met ontbrekende titels hebben verwijderd, bevat de dataset 19,675 recensies. Het finetunen van het Pegasus-model op een trainingsset met 70% van die artikelen gedurende vijf tijdperken duurde ongeveer 3.5 uur op een ml.p3.16xgrote instantie.

We kunnen het model vervolgens inzetten en testen met enkele voorbeeldgegevens uit de testset. Het volgende is een voorbeeldrecensie waarin een trui wordt beschreven:

# 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

Dankzij ons aangepaste inferentiescript dat wordt gehost in een SageMaker-eindpunt, kunnen we voor deze beoordeling verschillende samenvattingen genereren met verschillende tekstgeneratieparameters. We kunnen het eindpunt bijvoorbeeld vragen om een ​​reeks zeer korte tot matig lange samenvattingen te genereren die verschillende lengtestraffen specificeren (hoe kleiner de lengtestraf, hoe korter de gegenereerde samenvatting). Hieronder volgen enkele voorbeelden van parameterinvoer en de daaropvolgende door de machine gegenereerde samenvattingen:

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

Welke samenvatting heeft jouw voorkeur? De eerste gegenereerde titel bevat alle belangrijke feiten over de recensie, met een kwart van het aantal woorden. De laatste daarentegen gebruikt slechts drie woorden (minder dan 1/10e van de lengte van de oorspronkelijke recensie) om zich te concentreren op het belangrijkste kenmerk van de trui.

Conclusie

U kunt een tekstsamenvatting verfijnen op uw aangepaste dataset en deze implementeren in productie op SageMaker met dit eenvoudige voorbeeld dat beschikbaar is op GitHub. Extra voorbeeld notitieboekjes om Hugging Face-modellen te trainen en in te zetten op SageMaker zijn ook beschikbaar.

Zoals altijd verwelkomt AWS feedback. Dien uw opmerkingen of vragen in.

Referenties

[1] PEGASUS: Pre-training met geëxtraheerde gap-zinnen voor abstracte samenvatting

Over de auteurs

Victor Malesevi is een Machine Learning Engineer bij AWS Professional Services, gepassioneerd door natuurlijke taalverwerking en MLOps. Hij werkt samen met klanten om uitdagende deep learning-modellen te ontwikkelen en in productie te nemen op AWS. In zijn vrije tijd drinkt hij graag een glas rode wijn en wat kaas met vrienden.

Aamna Najmi is een datawetenschapper bij AWS Professional Services. Ze heeft een passie voor het helpen van klanten bij het innoveren met Big Data en Artificial Intelligence-technologieën om zakelijke waarde en inzichten uit data te halen. In haar vrije tijd houdt ze van tuinieren en reizen naar nieuwe plaatsen.