Natančno prilagodite in uvedite model povzemanja z vsebniki Hugging Face Amazon SageMaker, ki prinašajo vaš lasten skript

V zadnjem času je bilo na področju NLP veliko napredka. Vnaprej usposobljeni modeli in popolnoma upravljane NLP storitve so demokratizirale dostop in sprejemanje NLP. Amazonsko razumevanje je v celoti upravljana storitev, ki lahko izvaja naloge NLP, kot so prepoznavanje subjektov po meri, modeliranje tem, analiza razpoloženja in več, da pridobi vpoglede iz podatkov, ne da bi potrebovali predhodne izkušnje z ML.

Lansko leto je AWS napovedal a Partnerstvo z Objemni obraz za pomoč pri hitrejši uvedbi modelov za obdelavo naravnega jezika (NLP). Hugging Face je odprtokodna skupnost umetne inteligence, osredotočena na NLP. Njihova knjižnica, ki temelji na Pythonu (transformatorji) ponuja orodja za preprosto uporabo priljubljenih najsodobnejših arhitektur Transformer, kot so BERT, RoBERTa in GPT. Te modele lahko uporabite za različne naloge NLP, kot so klasifikacija besedila, pridobivanje informacij in odgovarjanje na vprašanja, med drugi.

Amazon SageMaker je popolnoma upravljana storitev, ki razvijalcem in podatkovnim znanstvenikom omogoča hitro gradnjo, usposabljanje in uvajanje modelov strojnega učenja (ML). SageMaker odstrani težko delo iz vsakega koraka procesa ML, kar olajša razvoj visokokakovostnih modelov. SDK SageMaker Python ponuja odprtokodne API-je in vsebnike za usposabljanje in uvajanje modelov na SageMaker z uporabo več različnih ogrodij ML in globokega učenja.

Integracija Hugging Face s SageMaker vam omogoča izdelavo modelov Hugging Face v velikem obsegu na vaših lastnih primerih uporabe, specifičnih za domeno.

V tej objavi vas vodimo skozi primer, kako zgraditi in razmestiti povzemalnik besedila Hugging Face po meri na SageMaker. Za ta namen uporabljamo Pegasus [1], prvi model, ki temelji na Transformerju in je posebej predhodno usposobljen za cilj, prilagojen za povzemanje abstraktnega besedila. BERT je predhodno usposobljen za maskiranje naključnih besed v stavku; v nasprotju s tem pa so med Pegasusovim predhodnim usposabljanjem stavki prikriti iz vhodnega dokumenta. Model nato generira manjkajoče stavke kot eno samo izhodno zaporedje z uporabo vseh nezamaskiranih stavkov kot konteksta in kot rezultat ustvari izvršni povzetek dokumenta.

Zahvaljujoč prilagodljivosti knjižnice HuggingFace lahko preprosto prilagodite kodo, prikazano v tej objavi, za druge vrste modelov transformatorjev, kot so t5, BART in drugi.

Naložite svoj nabor podatkov za natančno nastavitev modela Hugging Face

Za nalaganje nabora podatkov po meri iz datoteke CSV uporabimo load_dataset metoda iz paketa Transformers. Tokenizacijo lahko uporabimo za naložen nabor podatkov z uporabo datasets.Dataset.map funkcijo. The map funkcija ponovi naložen nabor podatkov in za vsak primer uporabi funkcijo tokenize. Tokenizirani nabor podatkov se lahko nato posreduje inštruktorju za natančno nastavitev modela. Oglejte si naslednjo kodo:

# 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

Sestavite svoj skript za usposabljanje za ocenjevalnik Hugging Face SageMaker

Kot je razloženo v objavi AWS in Hugging Face sodelujeta pri poenostavitvi in ​​pospešitvi sprejemanja modelov obdelave naravnega jezika, usposabljanje modela Hugging Face na SageMakerju še nikoli ni bilo lažje. To lahko storimo z uporabo ocenjevalca Hugging Face iz SDK SageMaker.

Naslednji delček kode natančno prilagodi Pegasus našemu naboru podatkov. Najdete jih tudi veliko vzorčni zvezki ki vas vodijo skozi natančno nastavitev različnih vrst modelov, ki so na voljo neposredno v repozitoriju transformers GitHub. Da omogočimo porazdeljeno usposabljanje, lahko uporabimo Knjižnica paralelizma podatkov v SageMakerju, ki je vgrajen v HuggingFace Trainer API. Da omogočimo vzporednost podatkov, moramo definirati distribution parameter v našem ocenjevalcu Hugging Face.

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

Največja velikost vadbene serije, ki jo lahko konfigurirate, je odvisna od velikosti modela in pomnilnika GPE uporabljenega primerka. Če je omogočeno porazdeljeno usposabljanje SageMaker, je skupna velikost serije vsota vsake serije, ki je porazdeljena po vsaki napravi/GPU. Če uporabimo ml.g4dn.16xlarge s porazdeljenim usposabljanjem namesto primerka ml.g4dn.xlarge, imamo osemkrat (8 grafičnih procesorjev) toliko pomnilnika kot primerek ml.g4dn.xlarge (1 grafični procesor). Velikost serije na napravo ostaja enaka, vendar se vzporedno usposablja osem naprav.

Kot običajno pri SageMakerju ustvarimo a train.py skript za uporabo s skriptnim načinom in posredovanje hiperparametrov za usposabljanje. Naslednji delček kode za Pegasus naloži model in ga uri s pomočjo Transformerjev Trainer razred:

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

Celotna koda je na voljo na GitHub.

Razmestite usposobljeni model Hugging Face v SageMaker

Naši prijatelji pri Hugging Face so sklepanje o modelih SageMaker for Transformers poenostavili kot kdaj koli SageMaker Hugging Face Inference Toolkit. Prej usposobljeni model lahko neposredno uvedete tako, da preprosto nastavite spremenljivko okolja "HF_TASK":"summarization" (za navodila glejte Modeli Pegasus), izbiranje uvajanje, in nato izbiranje Amazon SageMaker, ne da bi bilo treba napisati sklepni skript.

Če pa potrebujete določen način za generiranje ali naknadno obdelavo napovedi, na primer generiranje več predlogov povzetkov na podlagi seznama različnih parametrov za generiranje besedila, je pisanje lastnega sklepnega skripta lahko koristno in razmeroma preprosto:

# 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

Kot je prikazano v prejšnji kodi, potrebuje tak inferencialni skript za HuggingFace na SageMaker le naslednje funkcije predloge:

• model_fn () – Prebere vsebino tistega, kar je bilo shranjeno ob koncu usposabljanja SM_MODEL_DIR, ali iz obstoječega imenika uteži modela, shranjenega kot datoteka tar.gz v Preprosta storitev shranjevanja Amazon (Amazon S3). Uporablja se za nalaganje usposobljenega modela in povezanega tokenizatorja.
• input_fn () – Oblikuje podatke, prejete iz zahteve, poslane končni točki.
• predvidi_fn () – Prikliče izhod model_fn() (model in tokenizator), da izvede sklepanje na izhodu input_fn() (oblikovani podatki).

Po želji lahko ustvarite output_fn() funkcija za oblikovanje sklepanja z uporabo izhoda predict_fn(), česar v tej objavi nismo prikazali.

Nato lahko uvedemo izurjen model Hugging Face s pripadajočim sklepnim skriptom v SageMaker z uporabo Model objemajočega obraza SageMaker razred:

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

Preizkusite nameščeni model

Za to predstavitev smo usposobili model na Nabor podatkov o ocenah ženskih e-trgovinskih oblačil, ki vsebuje ocene oblačilnih artiklov (ki jih obravnavamo kot vhodno besedilo) in z njimi povezane naslove (ki jih obravnavamo kot povzetke). Ko odstranimo članke z manjkajočimi naslovi, nabor podatkov vsebuje 19,675 ocen. Natančna nastavitev modela Pegasus na učnem nizu, ki vsebuje 70 % teh člankov za pet epoh, je na primerku ml.p3.5xlarge trajala približno 3.16 ure.

Nato lahko uvedemo model in ga preizkusimo z nekaj vzorčnimi podatki iz testnega niza. Sledi primer ocene, ki opisuje pulover:

# 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

Zahvaljujoč našemu sklepnemu skriptu po meri, ki gostuje v končni točki SageMaker, lahko ustvarimo več povzetkov za ta pregled z različnimi parametri generiranja besedila. Na primer, od končne točke lahko zahtevamo, da ustvari vrsto zelo kratkih do zmerno dolgih povzetkov, ki določajo različne kazni za dolžino (manjša kot je kazen za dolžino, krajši je ustvarjeni povzetek). Sledi nekaj primerov vnosa parametrov in poznejši strojno ustvarjeni povzetki:

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

Kateri povzetek vam je ljubši? Prvi ustvarjeni naslov zajema vsa pomembna dejstva o recenziji, s četrtino manj besed. V nasprotju s tem zadnji uporablja samo tri besede (manj kot 1/10 dolžine prvotne ocene), da se osredotoči na najpomembnejšo lastnost puloverja.

zaključek

S tem preprostim primerom, ki je na voljo na strani GitHub. Dodatno vzorčni zvezki za usposabljanje in uvajanje modelov Hugging Face na SageMaker so na voljo tudi.

Kot vedno, AWS pozdravlja povratne informacije. Prosimo, pošljite kakršne koli pripombe ali vprašanja.

Reference

[1] PEGASUS: Predhodno usposabljanje z ekstrahiranimi vrzelnimi stavki za abstraktno povzemanje

O avtorjih

Viktor Malešević je inženir strojnega učenja pri AWS Professional Services, navdušen nad obdelavo naravnega jezika in MLOps. Sodeluje s strankami pri razvoju in uvajanju zahtevnih modelov globokega učenja v proizvodnjo na AWS. V prostem času si s prijatelji rad privošči kozarec rdečega vina in malo sira.

Aamna Najmi je podatkovni znanstvenik pri AWS Professional Services. Strastno želi pomagati strankam pri inovacijah s tehnologijami velikih podatkov in umetne inteligence, da iz podatkov izkoristijo poslovno vrednost in vpoglede. V prostem času rada vrtnari in potuje v nove kraje.