Peenhäälestage ja juurutage kokkuvõttemudel, kasutades Hugging Face Amazon SageMakeri konteinereid, mis toovad kaasa teie enda skripti

NLP-valdkonnas on hiljuti tehtud palju edusamme. Eelkoolitatud mudelid ja täielikult hallatavad NLP-teenused on võimaldanud NLP-le juurdepääsu ja selle kasutuselevõtu demokratiseerida. Amazoni mõistmine on täielikult hallatav teenus, mis suudab täita NLP-ülesandeid, nagu kohandatud olemituvastus, teemade modelleerimine, sentimentide analüüs ja palju muud, et hankida andmetest teadmisi, ilma et oleks vaja eelnevat ML-i kogemust.

Eelmisel aastal teatas AWS a partnerlus koos Kallistav nägu loomuliku keele töötlemise (NLP) mudelite kiiremaks toomiseks tootmisse. Hugging Face on avatud lähtekoodiga AI-kogukond, mis keskendub NLP-le. Nende Pythoni-põhine raamatukogu (Transformers) pakub tööriistu populaarsete tipptasemel transformeriarhitektuuride (nt BERT, RoBERTa ja GPT) hõlpsaks kasutamiseks. Saate neid mudeleid rakendada mitmesuguste NLP-ülesannete jaoks, nagu teksti klassifitseerimine, teabe eraldamine ja küsimustele vastamine. teised.

Amazon SageMaker on täielikult hallatav teenus, mis annab arendajatele ja andmeteadlastele võimaluse masinõppe (ML) mudeleid kiiresti luua, koolitada ja juurutada. SageMaker eemaldab ML-protsessi igast etapist raskuse, muutes kvaliteetsete mudelite väljatöötamise lihtsamaks. SageMaker Python SDK pakub avatud lähtekoodiga API-sid ja konteinereid mudelite koolitamiseks ja juurutamiseks SageMakeris, kasutades mitmeid erinevaid ML-i ja süvaõppe raamistikke.

Kallistava näo integreerimine SageMakeriga võimaldab teil luua mastaabis Kallistava näo mudeleid teie enda domeenispetsiifiliste kasutusjuhtude jaoks.

Selles postituses tutvustame teile näidet, kuidas luua ja juurutada SageMakeris kohandatud Kallistava näo teksti kokkuvõte. Kasutame selleks otstarbeks Pegasust [1], esimest transformeripõhist mudelit, mis on spetsiaalselt ette valmistatud abstraktse teksti kokkuvõtte tegemiseks kohandatud eesmärgiga. BERT on eelnevalt koolitatud juhuslike sõnade varjamiseks lauses; seevastu Pegasuse eelkoolituse ajal maskeeritakse lauseid sisenddokumendist. Seejärel genereerib mudel puuduvad laused ühe väljundjadana, kasutades kontekstina kõiki maskeerimata lauseid, luues selle tulemusel dokumendist kokkuvõtte.

Tänu HuggingFace'i teegi paindlikkusele saate hõlpsasti kohandada selles postituses näidatud koodi muud tüüpi trafomudelite jaoks, nagu t5, BART ja palju muud.

Kallistava näo mudeli peenhäälestamiseks laadige oma andmestik

Kohandatud andmestiku laadimiseks CSV-failist kasutame load_dataset meetod paketist Transformers. Saame rakendada laaditud andmekogumile tokeniseerimist, kasutades datasets.Dataset.map funktsioon. The map funktsioon kordab üle laaditud andmestiku ja rakendab iga näite puhul funktsiooni tokenize. Tokeniseeritud andmestiku saab seejärel mudeli peenhäälestamiseks koolitajale edastada. Vaadake järgmist koodi:

# 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

Koostage oma treeningskript Hugging Face SageMakeri hindaja jaoks

Nagu postituses selgitatud AWS ja Hugging Face teevad koostööd, et lihtsustada ja kiirendada loomuliku keele töötlemise mudelite kasutuselevõttu, Hugging Face modelli treenimine SageMakeris pole kunagi olnud lihtsam. Saame seda teha, kasutades Hugging Face hindajat rakendusest SageMaker SDK.

Järgmine koodilõik täpsustab Pegasust meie andmekogumis. Samuti võite leida palju näidismärkmikud mis juhendavad teid erinevat tüüpi mudelite peenhäälestamisel, mis on saadaval otse trafode GitHubi hoidlas. Jaotatud koolituse võimaldamiseks saame kasutada Andmeparallelismi raamatukogu SageMakeris, mis on sisse ehitatud HuggingFace Trainer API-sse. Andmete paralleelsuse lubamiseks peame määratlema distribution parameeter meie Hugging Face hindajas.

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

Konfigureeritav maksimaalne treeningpaki suurus sõltub mudeli suurusest ja kasutatud eksemplari GPU-mälust. Kui SageMakeri hajutatud koolitus on lubatud, on partii kogumaht iga seadme/GPU vahel jaotatud partii summa. Kui kasutame eksemplari ml.g4dn.xlarge asemel hajutatud väljaõppega ml.g16dn.4xlarge, on meil kaheksa korda (8 GPU-d) rohkem mälu kui ml.g4dn.xlarge eksemplaril (1 GPU). Partii suurus seadme kohta jääb samaks, kuid paralleelselt treenib kaheksa seadet.

Nagu SageMakeri puhul ikka, loome a train.py skript, mida saab kasutada koos skriptirežiimiga ja edastada treenimiseks hüperparameetrid. Järgmine Pegasuse koodilõik laadib mudeli ja treenib seda Transformerite abil Trainer klass:

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

Täielik kood on saadaval aadressil GitHub.

Kasutage SageMakeris koolitatud Hugging Face mudelit

Meie sõbrad Hugging Face'is on teinud SageMaker for Transformers mudelite kohta järeldusi lihtsamaks kui kunagi varem tänu SageMakeri kallistava näo järelduse tööriistakomplekt. Saate eelnevalt koolitatud mudelit otse juurutada, lihtsalt seadistades keskkonnamuutuja "HF_TASK":"summarization" (juhiseid vt Pegasuse mudelid), valides juurutadaja seejärel valides Amazon SageMaker, ilma et oleks vaja järeldusskripti kirjutada.

Kui aga vajate ennustuste genereerimiseks või järeltöötlemiseks mingit konkreetset viisi, näiteks mitme kokkuvõtliku soovituse loomist erinevate teksti genereerimise parameetrite loendi põhjal, võib oma järeldusskripti kirjutamine olla kasulik ja suhteliselt lihtne:

# 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

Nagu on näidatud eelmises koodis, vajab selline SageMakeri HuggingFace'i järeldusskript ainult järgmisi mallifunktsioone:

• model_fn() – Loeb sees koolitustöö lõpus salvestatu sisu SM_MODEL_DIRvõi olemasolevast mudelikaalude kataloogist, mis on salvestatud tar.gz-failina Amazoni lihtne salvestusteenus (Amazon S3). Seda kasutatakse koolitatud mudeli ja sellega seotud märgiseadi laadimiseks.
• input_fn() – vormindab lõpp-punktile tehtud päringust saadud andmed.
• ennusta_fn() – kutsub välja väljundi model_fn() (mudel ja tokenisaator), et teha järeldusi väljundi kohta input_fn() (vormindatud andmed).

Soovi korral saate luua output_fn() funktsioon järelduste vormindamiseks, kasutades väljundit predict_fn(), mida me selles postituses ei demonstreerinud.

Seejärel saame juurutada koolitatud Hugging Face mudeli koos sellega seotud järeldusskriptiga SageMakerisse, kasutades Kallistav nägu SageMaker mudel klass:

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

Testige juurutatud mudelit

Selle demo jaoks koolitasime mudelit Naiste e-kaubanduse rõivaarvustuste andmestik, mis sisaldab rõivaartiklite arvustusi (mida käsitleme sisendtekstina) ja nendega seotud pealkirju (mida käsitleme kokkuvõtetena). Pärast puuduvate pealkirjadega artiklite eemaldamist sisaldab andmekogum 19,675 70 arvustust. Pegasuse mudeli peenhäälestamine treeningkomplektil, mis sisaldas 3.5% nendest artiklitest viie perioodi jooksul, võttis ml.p3.16xsuurel eksemplaril umbes XNUMX tundi.

Seejärel saame mudeli juurutada ja testida mõne testkomplekti näidisandmetega. Järgmine on kampsunit kirjeldava ülevaate näide:

# 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

Tänu meie SageMakeri lõpp-punktis hostitud kohandatud järeldusskriptile saame selle ülevaate jaoks koostada mitu kokkuvõtet erinevate teksti genereerimise parameetritega. Näiteks võime paluda lõpp-punktil luua vahemiku väga lühikesi kuni mõõdukalt pikki kokkuvõtteid, mis määravad erineva pikkusega karistused (mida väiksem on pikkuse trahv, seda lühem on genereeritud kokkuvõte). Järgnevalt on toodud mõned parameetrite sisestusnäited ja järgnevad masinaga loodud kokkuvõtted.

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

Millist kokkuvõtet eelistate? Esimene loodud pealkiri sisaldab kõiki olulisi fakte arvustuse kohta, veerandi võrra vähem sõnu. Seevastu viimane kasutab kampsuni kõige olulisemale omadusele keskendumiseks vaid kolme sõna (vähem kui 1/10 algse arvustuse pikkusest).

Järeldus

Selle lihtsa näite abil saate oma kohandatud andmestiku teksti kokkuvõtte peenhäälestada ja juurutada selle SageMakeri tootmisse. GitHub. Lisaks näidismärkmikud Hugging Face mudelid SageMakeris on samuti saadaval koolitamiseks ja juurutamiseks.

Nagu alati, ootab AWS tagasisidet. Palun esitage kõik kommentaarid või küsimused.

viited

[1] PEGASUS: eeltreening abstraktse kokkuvõtte tegemiseks ekstraheeritud lünklausetega

Autoritest

Viktor Malesevic on AWS-i professionaalsete teenustega masinõppeinsener, kes on kirglik loomuliku keele töötlemise ja MLO-de vastu. Ta töötab koos klientidega, et arendada ja viia AWS-is välja väljakutseid pakkuvad süvaõppe mudelid. Vabal ajal naudib ta sõpradega klaasi punast veini ja juustu jagamist.

Aamna Najmi on AWS-i professionaalsete teenustega andmeteadlane. Ta soovib kirglikult aidata klientidel teha uuendusi suurandmete ja tehisintellekti tehnoloogiate abil, et saada andmetest äriväärtust ja teadmisi. Vabal ajal naudib ta aiatööd ja uutesse kohtadesse reisimist.