Hienosäädä ja ota käyttöön yhteenvetomalli käyttämällä Hugging Face Amazon SageMaker -säilöjä ja tuo mukanasi oman skriptisi

NLP-alueella on viime aikoina tapahtunut monia edistysaskeleita. Esikoulutetut mallit ja täysin hallitut NLP-palvelut ovat demokratisoineet NLP:n pääsyn ja käyttöönoton. Amazonin käsitys on täysin hallittu palvelu, joka pystyy suorittamaan NLP-tehtäviä, kuten mukautetun entiteetin tunnistusta, aiheen mallintamista, mielipideanalyysiä ja paljon muuta oivallusten poimimiseksi tiedoista ilman aikaisempaa ML-kokemusta.

Viime vuonna AWS ilmoitti a kumppanuus with Halaaminen kasvot auttaa tuomaan luonnollisen kielen käsittelymalleja (NLP) nopeammin tuotantoon. Hugging Face on avoimen lähdekoodin tekoälyyhteisö, joka keskittyy NLP:hen. Heidän Python-pohjainen kirjastonsa (Muuntajat) tarjoaa työkaluja, joiden avulla voit helposti käyttää suosittuja huippuluokan Transformer-arkkitehtuureja, kuten BERT, RoBERTa ja GPT. Voit soveltaa näitä malleja erilaisiin NLP-tehtäviin, kuten tekstin luokitteluun, tiedon poimimiseen ja kysymyksiin vastaamiseen. muut.

Amazon Sage Maker on täysin hallittu palvelu, joka tarjoaa kehittäjille ja datatieteilijöille mahdollisuuden rakentaa, kouluttaa ja ottaa käyttöön koneoppimismalleja (ML) nopeasti. SageMaker poistaa raskaan noston jokaisesta ML-prosessin vaiheesta, mikä helpottaa korkealaatuisten mallien kehittämistä. SageMaker Python SDK tarjoaa avoimen lähdekoodin sovellusliittymiä ja säilöjä mallien kouluttamiseen ja käyttöönottoon SageMakerissa käyttämällä useita erilaisia ​​ML- ja syväoppimiskehyksiä.

Hugging Face -integraatio SageMakerin kanssa mahdollistaa Hugging Face -mallien rakentamisen mittakaavassa omiin verkkotunnuskohtaisiin käyttötapauksiin.

Tässä viestissä opastamme sinut läpi esimerkin mukautetun Hugging Face -tekstin yhteenvedon rakentamisesta ja käyttöönotosta SageMakerissa. Käytämme tähän tarkoitukseen Pegasusta [1], ensimmäistä Transformer-pohjaista mallia, joka on erityisesti esikoulutettu abstraktia tekstin yhteenvetoa varten räätälöityyn tavoitteeseen. BERT on valmiiksi koulutettu peittämään satunnaisia ​​sanoja lauseessa; Sitä vastoin Pegasuksen esikoulutuksen aikana lauseet peitetään syötedokumentista. Malli luo sitten puuttuvat lauseet yhtenä tulossekvenssinä käyttämällä kaikkia peittämättömiä lauseita kontekstina, ja tuloksena luodaan asiakirjasta yhteenveto.

HuggingFace-kirjaston joustavuuden ansiosta voit helposti mukauttaa tässä viestissä näkyvän koodin muun tyyppisiin muuntajamalleihin, kuten t5, BART ja muihin.

Lataa oma tietojoukosi hienosäätääksesi Hugging Face -mallia

Käytämme mukautetun tietojoukon lataamiseen CSV-tiedostosta load_dataset menetelmä Transformers-paketista. Voimme käyttää tokenointia ladatussa tietojoukossa käyttämällä datasets.Dataset.map toimia. map funktio iteroituu ladatun tietojoukon yli ja käyttää tokenize-funktiota jokaisessa esimerkissä. Tokenoitu tietojoukko voidaan sitten välittää kouluttajalle mallin hienosäätöä varten. Katso seuraava 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

Rakenna harjoitusskripti Hugging Face SageMaker -estimaattoria varten

Kuten postauksessa selitettiin AWS ja Hugging Face yksinkertaistavat ja nopeuttavat luonnollisen kielen käsittelymallien käyttöönottoa, Hugging Face -mallin kouluttaminen SageMakerilla ei ole koskaan ollut näin helppoa. Voimme tehdä sen käyttämällä Hugging Face -estimaattoria SageMaker SDK.

Seuraava koodinpätkä hienosäätää Pegasusta tietojoukossamme. Löydät myös monia näytekannettavat jotka opastavat sinua erityyppisten mallien hienosäädössä, jotka ovat saatavilla suoraan muuntajien GitHub-arkistosta. Hajautetun koulutuksen mahdollistamiseksi voimme käyttää Data Parallelism Library SageMakerissa, joka on sisäänrakennettu HuggingFace Trainer -sovellusliittymään. Tietojen rinnakkaisuuden mahdollistamiseksi meidän on määritettävä distribution -parametri Hugging Face -estimaattorissamme.

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

Suurin määritettävissä oleva harjoituserän koko riippuu mallin koosta ja käytetyn ilmentymän GPU-muistista. Jos SageMakerin hajautettu koulutus on käytössä, erän kokonaiskoko on jokaisen laitteen/GPU:n kesken jaetun erän summa. Jos käytämme ml.g4dn.16xlargea hajautetun harjoittelun kanssa ml.g4dn.xlarge-instanssin sijaan, meillä on kahdeksan kertaa (8 GPU:ta) enemmän muistia kuin ml.g4dn.xlarge-esiintymässä (1 GPU). Eräkoko laitetta kohti pysyy samana, mutta kahdeksan laitetta harjoittelee rinnakkain.

Kuten SageMakerissa tavallista, luomme a train.py komentosarja käytettäväksi Script Moden kanssa ja siirtää hyperparametrit harjoittelua varten. Seuraava Pegasuksen koodinpätkä lataa mallin ja harjoittelee sitä Transformersin avulla Trainer luokka:

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

Koko koodi on saatavilla osoitteessa GitHub.

Ota koulutettu Hugging Face -malli käyttöön SageMakerissa

Hugging Facen ystävämme ovat tehneet johtopäätöksen SageMaker for Transformers -malleista helpommin kuin koskaan, kiitos SageMaker Hugging Face Inference Toolkit. Voit ottaa suoraan käyttöön aiemmin koulutetun mallin yksinkertaisesti määrittämällä ympäristömuuttujan "HF_TASK":"summarization" (ohjeet, katso Pegasus-mallit), valitsemalla Sijoittaaja valitse sitten Amazon Sage Maker, tarvitsematta kirjoittaa päättelykomentosarjaa.

Jos kuitenkin tarvitset tietyn tavan luoda tai jälkikäsitellä ennusteita, esimerkiksi luoda useita yhteenvetoehdotuksia, jotka perustuvat erilaisten tekstin luontiparametrien luetteloon, oman päättelyskriptin kirjoittaminen voi olla hyödyllistä ja suhteellisen yksinkertaista:

# 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

Kuten edellisessä koodissa näkyy, tällainen HuggingFacen päättelyskripti SageMakerissa tarvitsee vain seuraavat mallipohjatoiminnot:

• model_fn () – Lukee sisälle koulutustyön lopussa tallennetun sisällön SM_MODEL_DIR, tai olemassa olevasta mallipainojen hakemistosta, joka on tallennettu tar.gz-tiedostona Amazonin yksinkertainen tallennuspalvelu (Amazon S3). Sitä käytetään koulutetun mallin ja siihen liittyvän tokenisaattorin lataamiseen.
• input_fn () – Muotoilee päätepisteelle tehdystä pyynnöstä saadut tiedot.
• predict_fn () – Kutsuu tulosteen model_fn() (malli ja tokenizer) suorittaaksesi päätelmän tulosteesta input_fn() (muotoiltu data).

Valinnaisesti voit luoda output_fn() toiminto päätelmien muotoiluun käyttämällä tulostetta predict_fn(), jota emme osoittaneet tässä viestissä.

Voimme sitten ottaa käyttöön koulutetun Hugging Face -mallin ja siihen liittyvän päättelyskriptin SageMakeriin käyttämällä Halaavat kasvot SageMaker-malli luokka:

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

Testaa käytössä olevaa mallia

Tätä demoa varten koulutimme mallin Naisten verkkokaupan vaatteiden arvostelut -tietojoukko, joka sisältää arvosteluja vaateartikkeleista (jotka pidämme syötetekstinä) ja niihin liittyvistä otsikoista (jotka pidämme yhteenvetoina). Kun olemme poistaneet artikkelit, joiden otsikoista puuttuu, tietojoukko sisältää 19,675 70 arvostelua. Pegasus-mallin hienosäätö harjoitussarjassa, joka sisälsi 3.5 % näistä artikkeleista viiden aikakauden ajalta, kesti noin 3.16 tuntia ml.pXNUMXx-suuressa tapauksessa.

Voimme sitten ottaa mallin käyttöön ja testata sitä jollain testijoukon esimerkkidatalla. Seuraavassa on esimerkkiarvostelu, jossa kuvataan villapaita:

# 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

SageMaker-päätepisteessä isännöidyn mukautetun päätelmäskriptimme ansiosta voimme luoda useita yhteenvetoja tätä tarkistusta varten erilaisilla tekstin luontiparametreilla. Voimme esimerkiksi pyytää päätepistettä luomaan joukon hyvin lyhyitä tai kohtalaisen pitkiä yhteenvetoja, joissa määritellään eripituiset rangaistukset (mitä pienempi pituusrangaistus, sitä lyhyempi luotu yhteenveto). Seuraavassa on joitain parametrien syöttöesimerkkejä ja niitä seuraavat koneella luodut yhteenvedot:

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

Kummasta yhteenvedosta pidät enemmän? Ensimmäinen luotu otsikko sisältää kaikki tärkeät faktat arvostelusta neljänneksen sanojen määrällä. Sitä vastoin viimeinen käyttää vain kolmea sanaa (alle 1/10 alkuperäisen arvostelun pituudesta) keskittyäkseen puseron tärkeimpään ominaisuuteen.

Yhteenveto

Voit hienosäätää mukautetun tietojoukon tekstin yhteenvedon ja ottaa sen käyttöön SageMakerin tuotannossa tämän yksinkertaisen esimerkin avulla. GitHub. lisä- näytekannettavat Hugging Face -mallit ovat myös saatavilla SageMakerin kouluttamiseen ja käyttöönottoon.

Kuten aina, AWS suhtautuu myönteisesti palautteeseen. Lähetä kommentteja tai kysymyksiä.

Viitteet

[1] PEGASUS: Esiharjoittelu purettujen aukkolauseiden avulla abstraktia yhteenvetoa varten

Tietoja kirjoittajista

Viktor Malesevic on koneoppimisinsinööri, jolla on AWS-asiantuntijapalvelut, ja hän on intohimoinen luonnollisen kielen prosessoinnista ja MLOpsista. Hän työskentelee asiakkaiden kanssa kehittääkseen ja tuodakseen haastavia syväoppimismalleja AWS:n tuotantoon. Vapaa-ajallaan hän nauttii lasillisen punaviiniä ja juustoa ystävien kanssa.

Aamna Najmi on tietotutkija, jolla on AWS Professional Services. Hän on intohimoinen auttamaan asiakkaita innovoimaan Big Data- ja tekoälytekniikoilla, jotta he voivat hyödyntää datasta liiketoiminta-arvoa ja oivalluksia. Vapaa-ajallaan hän nauttii puutarhanhoidosta ja matkustamisesta uusiin paikkoihin.