Finjuster og implementer en summarizer-model ved hjælp af Hugging Face Amazon SageMaker-beholderne, der bringer dit eget script

Der har været mange nye fremskridt inden for NLP-domænet. Foruddannede modeller og fuldt administrerede NLP-tjenester har demokratiseret adgang og adoption af NLP. Amazon Comprehend er en fuldt administreret tjeneste, der kan udføre NLP-opgaver som brugerdefineret enhedsgenkendelse, emnemodellering, sentimentanalyse og mere for at udtrække indsigt fra data uden behov for nogen tidligere ML-erfaring.

Sidste år annoncerede AWS en partnerskab med Knusende ansigt for at hjælpe med at bringe NLP-modeller (natural language processing) til produktion hurtigere. Hugging Face er et open source AI-fællesskab med fokus på NLP. Deres Python-baserede bibliotek (transformers) giver værktøjer til nemt at bruge populære state-of-the-art Transformer-arkitekturer som BERT, RoBERTa og GPT. Du kan anvende disse modeller til en række NLP-opgaver, såsom tekstklassificering, informationsudtrækning og besvarelse af spørgsmål, bl.a. andre.

Amazon SageMaker er en fuldt administreret tjeneste, der giver udviklere og datavidenskabsfolk mulighed for hurtigt at bygge, træne og implementere maskinlæringsmodeller (ML). SageMaker fjerner de tunge løft fra hvert trin i ML-processen, hvilket gør det nemmere at udvikle modeller af høj kvalitet. SageMaker Python SDK leverer open source API'er og containere til at træne og implementere modeller på SageMaker ved hjælp af flere forskellige ML- og deep learning-rammer.

Hugging Face-integrationen med SageMaker giver dig mulighed for at bygge Hugging Face-modeller i stor skala på dine egne domænespecifikke use cases.

I dette indlæg leder vi dig gennem et eksempel på, hvordan du opbygger og implementerer en tilpasset Hugging Face-tekstsammendrag på SageMaker. Vi bruger Pegasus [1] til dette formål, den første Transformer-baserede model, der er specifikt fortrænet på et mål, der er skræddersyet til abstrakt tekstresumé. BERT er fortrænet i at maskere tilfældige ord i en sætning; i modsætning hertil maskeres sætninger under Pegasus' fortræning fra et inputdokument. Modellen genererer derefter de manglende sætninger som en enkelt output-sekvens ved at bruge alle de umaskerede sætninger som kontekst, hvilket skaber et resumé af dokumentet som et resultat.

Takket være fleksibiliteten i HuggingFace-biblioteket kan du nemt tilpasse koden vist i dette indlæg til andre typer transformermodeller, såsom t5, BART og mere.

Indlæs dit eget datasæt for at finjustere en Hugging Face-model

For at indlæse et brugerdefineret datasæt fra en CSV-fil bruger vi load_dataset metode fra Transformers-pakken. Vi kan anvende tokenisering på det indlæste datasæt ved hjælp af datasets.Dataset.map fungere. Det map funktion itererer over det indlæste datasæt og anvender tokenize-funktionen til hvert eksempel. Det tokeniserede datasæt kan derefter videregives til træneren for at finjustere modellen. Se følgende kode:

# 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

Byg dit træningsscript til Hugging Face SageMaker-estimatoren

Som forklaret i indlægget AWS og Hugging Face samarbejder om at forenkle og fremskynde overtagelsen af ​​Natural Language Processing-modeller, at træne en Hugging Face-model på SageMaker har aldrig været nemmere. Det kan vi gøre ved at bruge Hugging Face-estimatoren fra SageMaker SDK.

Følgende kodestykke finjusterer Pegasus på vores datasæt. Du kan også finde mange eksempler på notesbøger der guider dig gennem finjustering af forskellige typer modeller, tilgængelige direkte i transformatorernes GitHub-lager. For at muliggøre distribueret træning kan vi bruge Dataparallelismebibliotek i SageMaker, som er indbygget i HuggingFace Trainer API. For at muliggøre dataparallelisme er vi nødt til at definere distribution parameter i vores Hugging Face-estimator.

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

Den maksimale træningsbatchstørrelse, du kan konfigurere, afhænger af modelstørrelsen og GPU-hukommelsen for den anvendte instans. Hvis SageMaker distribueret træning er aktiveret, er den samlede batchstørrelse summen af ​​hver batch, der er fordelt på hver enhed/GPU. Hvis vi bruger en ml.g4dn.16xlarge med distribueret træning i stedet for en ml.g4dn.xlarge instans, har vi otte gange (8 GPU'er) så meget hukommelse som en ml.g4dn.xlarge instans (1 GPU). Batchstørrelsen pr. enhed forbliver den samme, men otte enheder træner parallelt.

Som sædvanligt med SageMaker opretter vi en train.py script til brug med Script-tilstand og videregive hyperparametre til træning. Følgende kodestykke til Pegasus indlæser modellen og træner den ved hjælp af 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 fulde kode er tilgængelig på GitHub.

Implementer den trænede Hugging Face-model til SageMaker

Vores venner hos Hugging Face har gjort konklusioner om SageMaker for Transformers-modeller enklere end nogensinde takket være SageMaker Hugging Face Inference Toolkit. Du kan implementere den tidligere trænede model direkte ved blot at opsætte miljøvariablen "HF_TASK":"summarization" (for instruktioner, se Pegasus modeller), vælger Implementer, og derefter vælge Amazon SageMakeruden at skulle skrive et slutningsskrift.

Men hvis du har brug for en specifik måde at generere eller efterbehandle forudsigelser på, for eksempel at generere flere resuméforslag baseret på en liste over forskellige tekstgenereringsparametre, kan det være nyttigt og relativt ligetil at skrive dit eget slutningsscript:

# 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

Som vist i den foregående kode behøver et sådant inferensscript til HuggingFace på SageMaker kun følgende skabelonfunktioner:

• model_fn() – Læser indholdet af, hvad der blev gemt i slutningen af ​​træningsjobbet inde SM_MODEL_DIR, eller fra en eksisterende modelvægte-mappe gemt som en tar.gz-fil i Amazon Simple Storage Service (Amazon S3). Den bruges til at indlæse den trænede model og tilhørende tokenizer.
• input_fn() – Formaterer de data, der er modtaget fra en anmodning til slutpunktet.
• forudsige_fn() – Kalder udgangen af model_fn() (modellen og tokenizer) til at køre slutninger om outputtet af input_fn() (de formaterede data).

Eventuelt kan du oprette en output_fn() funktion til inferensformatering ved hjælp af output fra predict_fn(), som vi ikke demonstrerede i dette indlæg.

Vi kan derefter implementere den trænede Hugging Face-model med dets tilhørende inferensscript til SageMaker ved hjælp af Knusende ansigt 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 den installerede model

Til denne demo trænede vi modellen på Kvinders e-handelstøjsanmeldelser datasæt, som indeholder anmeldelser af tøjartikler (som vi betragter som inputteksten) og deres tilhørende titler (som vi betragter som resuméer). Efter at vi har fjernet artikler med manglende titler, indeholder datasættet 19,675 anmeldelser. Finjustering af Pegasus-modellen på et træningssæt indeholdende 70 % af disse artikler i fem epoker tog cirka 3.5 timer på en ml.p3.16xlarge instans.

Vi kan derefter implementere modellen og teste den med nogle eksempeldata fra testsættet. Følgende er et eksempel på en anmeldelse, der beskriver en sweater:

# 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

Takket være vores brugerdefinerede inferensscript, der er hostet i et SageMaker-slutpunkt, kan vi generere flere resuméer til denne anmeldelse med forskellige tekstgenereringsparametre. For eksempel kan vi bede endepunktet om at generere en række meget korte til moderat lange resuméer, der specificerer forskellige længdestraffe (jo mindre længde straf, jo kortere er den genererede oversigt). Følgende er nogle eksempler på parameterindtastning og de efterfølgende maskingenererede oversigter:

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

Hvilket resumé foretrækker du? Den først genererede titel fanger alle de vigtige fakta om anmeldelsen med en fjerdedel af antallet af ord. I modsætning hertil bruger den sidste kun tre ord (mindre end 1/10 af længden af ​​den originale anmeldelse) for at fokusere på det vigtigste træk ved sweateren.

Konklusion

Du kan finjustere en tekstsammendrag på dit brugerdefinerede datasæt og implementere det til produktion på SageMaker med dette enkle eksempel tilgængeligt på GitHub. Ekstra eksempler på notesbøger at træne og implementere Hugging Face-modeller på SageMaker er også tilgængelige.

Som altid modtager AWS gerne feedback. Indsend venligst eventuelle kommentarer eller spørgsmål.

Referencer

[1] PEGASUS: Fortræning med ekstraherede mellemrumssætninger til abstrakt opsummering

Om forfatterne

Viktor Malesevic er en maskinlæringsingeniør med AWS Professional Services, passioneret omkring Natural Language Processing og MLOps. Han arbejder sammen med kunder om at udvikle og sætte udfordrende deep learning-modeller i produktion på AWS. I sin fritid nyder han at dele et glas rødvin og lidt ost med vennerne.

Aamna Najmi er dataforsker med AWS Professional Services. Hun brænder for at hjælpe kunder med at innovere med Big Data og Artificial Intelligence-teknologier for at udnytte forretningsværdi og indsigt fra data. I sin fritid nyder hun havearbejde og rejser til nye steder.