Finjuster og distribuer en oppsummeringsmodell ved å bruke Hugging Face Amazon SageMaker-beholdere med ditt eget manus

Det har vært mange nye fremskritt i NLP-domenet. Forhåndsutdannede modeller og fullstendig administrerte NLP-tjenester har demokratisert tilgang og bruk av NLP. Amazon Comprehend er en fullstendig administrert tjeneste som kan utføre NLP-oppgaver som tilpasset enhetsgjenkjenning, emnemodellering, sentimentanalyse og mer for å trekke ut innsikt fra data uten behov for noen tidligere ML-erfaring.

I fjor kunngjorde AWS en partnerskap med Klemme ansiktet for å bidra til å bringe NLP-modeller (natural language processing) til produksjon raskere. Hugging Face er et åpen kildekode AI-fellesskap, fokusert på NLP. Deres Python-baserte bibliotek (transformers) gir verktøy for enkelt å bruke populære toppmoderne transformatorarkitekturer som BERT, RoBERTa og GPT. Du kan bruke disse modellene på en rekke NLP-oppgaver, for eksempel tekstklassifisering, informasjonsutvinning og spørsmålssvar, blant annet andre.

Amazon SageMaker er en fullstendig administrert tjeneste som gir utviklere og dataforskere muligheten til å bygge, trene og distribuere maskinlæringsmodeller (ML) raskt. SageMaker fjerner de tunge løftene fra hvert trinn i ML-prosessen, noe som gjør det enklere å utvikle høykvalitetsmodeller. SageMaker Python SDK gir åpen kildekode APIer og containere for å trene og distribuere modeller på SageMaker, ved å bruke flere forskjellige ML- og dyplæringsrammer.

Hugging Face-integrasjonen med SageMaker lar deg bygge Hugging Face-modeller i stor skala på dine egne domenespesifikke brukstilfeller.

I dette innlegget leder vi deg gjennom et eksempel på hvordan du bygger og distribuerer en tilpasset Hugging Face-tekstsammendrag på SageMaker. Vi bruker Pegasus [1] til dette formålet, den første transformatorbaserte modellen spesifikt forhåndstrent på et mål skreddersydd for abstrakt tekstoppsummering. BERT er forhåndstrent på å maskere tilfeldige ord i en setning; i kontrast, under Pegasus sin fortrening, maskeres setninger fra et input-dokument. Modellen genererer deretter de manglende setningene som en enkelt utdatasekvens ved å bruke alle de demaskerte setningene som kontekst, og skaper et sammendrag av dokumentet som et resultat.

Takket være fleksibiliteten til HuggingFace-biblioteket kan du enkelt tilpasse koden vist i dette innlegget for andre typer transformatormodeller, som t5, BART og mer.

Last inn ditt eget datasett for å finjustere en Hugging Face-modell

For å laste et tilpasset datasett fra en CSV-fil, bruker vi load_dataset metode fra Transformers-pakken. Vi kan bruke tokenisering på det nedlastede datasettet ved å bruke datasets.Dataset.map funksjon. De map funksjonen itererer over det innlastede datasettet og bruker tokenize-funksjonen på hvert eksempel. Det tokeniserte datasettet kan deretter sendes til treneren for å 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

Bygg treningsskriptet for Hugging Face SageMaker-estimatoren

Som forklart i innlegget AWS og Hugging Face samarbeider for å forenkle og akselerere adopsjonen av Natural Language Processing-modeller, å trene en Hugging Face-modell på SageMaker har aldri vært enklere. Vi kan gjøre det ved å bruke Hugging Face-estimatoren fra SageMaker SDK.

Følgende kodebit finjusterer Pegasus på datasettet vårt. Du kan også finne mange eksempel på notatbøker som veileder deg gjennom finjustering av forskjellige typer modeller, tilgjengelig direkte i transformatorene GitHub-lageret. For å aktivere distribuert opplæring kan vi bruke Dataparallellismebibliotek i SageMaker, som er innebygd i HuggingFace Trainer API. For å muliggjøre dataparallellisme, må vi definere distribution parameter i vår 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 treningsbatchstørrelsen du kan konfigurere avhenger av modellstørrelsen og GPU-minnet til forekomsten som brukes. Hvis SageMaker distribuert opplæring er aktivert, er den totale batchstørrelsen summen av hver batch som er distribuert over hver enhet/GPU. Hvis vi bruker en ml.g4dn.16xlarge med distribuert trening i stedet for en ml.g4dn.xlarge-instans, har vi åtte ganger (8 GPUer) så mye minne som en ml.g4dn.xlarge-instans (1 GPU). Batchstørrelsen per enhet forblir den samme, men åtte enheter trener parallelt.

Som vanlig med SageMaker lager vi en train.py skript som skal brukes med skriptmodus og sende hyperparametre for trening. Følgende kodebit for Pegasus laster modellen og trener den ved hjelp av 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-*/")

Hele koden er tilgjengelig på GitHub.

Distribuer den trente Hugging Face-modellen til SageMaker

Våre venner i Hugging Face har gjort slutninger om SageMaker for Transformers-modeller enklere enn noen gang takket være SageMaker Hugging Face Inference Toolkit. Du kan distribuere den tidligere opplærte modellen direkte ved ganske enkelt å sette opp miljøvariabelen "HF_TASK":"summarization" (for instruksjoner, se Pegasus modeller), velger Distribuer, og deretter velge Amazon SageMaker, uten å måtte skrive et slutningsskript.

Men hvis du trenger en spesifikk måte å generere eller etterbehandle spådommer på, for eksempel å generere flere oppsummeringsforslag basert på en liste over forskjellige tekstgenereringsparametre, kan det å skrive ditt eget slutningsskript være nyttig og relativt enkelt:

# 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 koden, trenger et slikt slutningsskript for HuggingFace på SageMaker bare følgende malfunksjoner:

• modell_fn () – Leser innholdet i det som ble lagret på slutten av treningsjobben inne SM_MODEL_DIR, eller fra en eksisterende modellvekter-katalog lagret som en tar.gz-fil i Amazon enkel lagringstjeneste (Amazon S3). Den brukes til å laste den trente modellen og tilhørende tokenizer.
• input_fn () – Formaterer dataene mottatt fra en forespørsel til endepunktet.
• predict_fn () – Kaller utgangen til model_fn() (modellen og tokenizer) for å kjøre slutninger om utgangen av input_fn() (de formaterte dataene).

Eventuelt kan du opprette en output_fn() funksjon for inferensformatering, ved å bruke utdata fra predict_fn(), som vi ikke demonstrerte i dette innlegget.

Vi kan deretter distribuere den trente Hugging Face-modellen med tilhørende slutningsskript til SageMaker ved å bruke Hugging Face 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 utplasserte modellen

For denne demoen trente vi modellen på Klær anmeldelser for kvinners e-handel datasett, som inneholder anmeldelser av klesartikler (som vi anser som inngangstekst) og tilhørende titler (som vi anser som sammendrag). Etter at vi har fjernet artikler med manglende titler, inneholder datasettet 19,675 70 anmeldelser. Finjustering av Pegasus-modellen på et treningssett som inneholder 3.5 % av disse artiklene i fem epoker tok omtrent 3.16 timer på en ml.pXNUMXxlarge forekomst.

Vi kan deretter distribuere modellen og teste den med noen eksempeldata fra testsettet. Følgende er et eksempel på en anmeldelse som beskriver en genser:

# 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 vårt tilpassede slutningsskript som er vert i et SageMaker-endepunkt, kan vi generere flere sammendrag for denne anmeldelsen med forskjellige tekstgenereringsparametere. For eksempel kan vi be endepunktet om å generere en rekke svært korte til moderat lange oppsummeringer som spesifiserer straffer med forskjellig lengde (jo mindre lengde straff, jo kortere generert oppsummering). Følgende er noen eksempler på parameterinndata og de påfølgende maskingenererte sammendragene:

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

Hvilken oppsummering foretrekker du? Den første genererte tittelen fanger opp alle viktige fakta om anmeldelsen, med en fjerdedel av antall ord. Derimot bruker den siste bare tre ord (mindre enn 1/10 av lengden på den originale anmeldelsen) for å fokusere på det viktigste ved genseren.

konklusjonen

Du kan finjustere en tekstoppsummerer på det tilpassede datasettet ditt og distribuere det til produksjon på SageMaker med dette enkle eksemplet tilgjengelig på GitHub. Ytterligere eksempel på notatbøker å trene og distribuere Hugging Face-modeller på SageMaker er også tilgjengelige.

Som alltid tar AWS gjerne tilbakemeldinger. Send inn eventuelle kommentarer eller spørsmål.

Referanser

[1] PEGASUS: Pre-trening med ekstraherte gap-setninger for abstrakt oppsummering

Om forfatterne

Viktor Malesevic er en maskinlæringsingeniør med AWS Professional Services, lidenskapelig opptatt av naturlig språkbehandling og MLOps. Han jobber med kunder for å utvikle og sette utfordrende dyplæringsmodeller i produksjon på AWS. På fritiden liker han å dele et glass rødvin og litt ost med venner.

Aamna Najmi er en dataforsker med AWS Professional Services. Hun brenner for å hjelpe kunder med å innovere med Big Data og Artificial Intelligence-teknologier for å utnytte forretningsverdi og innsikt fra data. På fritiden liker hun hagearbeid og reiser til nye steder.