Finomhangoljon és helyezzen üzembe egy összefoglaló modellt a Hugging Face Amazon SageMaker konténerek segítségével, és hozza létre saját szkriptjét

A közelmúltban számos előrelépés történt az NLP területén. Az előre betanított modellek és a teljes körűen felügyelt NLP-szolgáltatások demokratizálták az NLP hozzáférését és elfogadását. Amazon Comprehend egy teljesen felügyelt szolgáltatás, amely képes végrehajtani az NLP-feladatokat, például egyéni entitásfelismerést, témamodellezést, hangulatelemzést és még sok minden mást, hogy betekintést nyerjen az adatokból előzetes ML-tapasztalat nélkül.

Tavaly az AWS bejelentette a partnerség val vel Átölelő arc hogy a természetes nyelvi feldolgozási (NLP) modellek gyorsabban gyártásba kerüljenek. A Hugging Face egy nyílt forráskódú mesterséges intelligencia közösség, amely az NLP-re összpontosít. Python alapú könyvtáruk (transzformerek) eszközöket biztosít a népszerű Transformer architektúrák, például a BERT, a RoBERTa és a GPT egyszerű használatához. Ezeket a modelleket számos NLP-feladatra alkalmazhatja, mint például a szövegosztályozás, az információ kinyerése és a kérdések megválaszolása. mások.

Amazon SageMaker egy teljesen felügyelt szolgáltatás, amely lehetővé teszi a fejlesztők és adattudósok számára a gépi tanulási (ML) modellek gyors felépítését, betanítását és üzembe helyezését. A SageMaker az ML folyamat minden egyes lépéséből eltávolítja a nehéz terheket, megkönnyítve a kiváló minőségű modellek fejlesztését. A SageMaker Python SDK nyílt forráskódú API-kat és konténereket biztosít a modellek betanításához és üzembe helyezéséhez a SageMakeren, számos különböző ML és mély tanulási keretrendszer használatával.

A Hugging Face integrációja a SageMakerrel lehetővé teszi, hogy a saját domain-specifikus felhasználási esetei szerint nagy léptékű Hugging Face modelleket készítsen.

Ebben a bejegyzésben bemutatunk egy példát arra vonatkozóan, hogyan hozhat létre és helyezhet üzembe egyéni átölelő arc szövegösszefoglalót a SageMakeren. Erre a célra a Pegasust [1] használjuk, az első Transformer-alapú modellt, amelyet kifejezetten egy absztrakt szövegösszegzésre szabott objektívre készítettek elő. A BERT előre képzett a véletlenszerű szavak elfedésére egy mondatban; ezzel szemben Pegasus előképzése során a mondatokat egy bemeneti dokumentumból maszkírozzák. A modell ezután egyetlen kimeneti sorozatként generálja a hiányzó mondatokat, az összes maszkolt mondatot kontextusként felhasználva, és ennek eredményeként létrehozza a dokumentum összefoglalóját.

A HuggingFace könyvtár rugalmasságának köszönhetően könnyen adaptálhatja az ebben a bejegyzésben látható kódot más típusú transzformátormodellekhez, mint például a t5, BART stb.

Töltsd be saját adatkészletedet, hogy finomhangolhasd a Hugging Face modellt

Egyéni adatkészlet CSV-fájlból történő betöltéséhez a load_dataset módszer a Transformers csomagból. A betöltött adatkészletre tokenizálást alkalmazhatunk a datasets.Dataset.map funkció. A map A függvény a betöltött adatkészleten iterál, és minden példára alkalmazza a tokenize függvényt. A tokenizált adatkészlet ezután átadható a trénernek a modell finomhangolásához. Lásd a következő kódot:

# 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

Készítse el edzési szkriptjét a Hugging Face SageMaker becslőhöz

Ahogy a posztban kifejtették Az AWS és a Hugging Face együttműködik a természetes nyelvi feldolgozási modellek egyszerűsítése és felgyorsítása érdekében, Hugging Face modell képzése a SageMakeren még soha nem volt ilyen egyszerű. Ezt megtehetjük a Hugging Face becslő segítségével a SageMaker SDK.

A következő kódrészlet finomhangolja a Pegasust az adatkészletünkön. Sokakat is találhatsz mintafüzetek amelyek végigvezetik Önt a különböző típusú modellek finomhangolásán, amelyek közvetlenül elérhetők a transzformátorok GitHub tárházában. Az elosztott képzés engedélyezéséhez használhatjuk a Data Parallelism Library a SageMakerben, amelyet a HuggingFace Trainer API-ba építettek be. Az adatok párhuzamosságának engedélyezéséhez meg kell határoznunk a distribution paramétert a Hugging Face becslőben.

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

A konfigurálható maximális betanítási kötegméret a modell méretétől és a használt példány GPU-memóriájától függ. Ha a SageMaker elosztott képzés engedélyezve van, a teljes kötegméret az egyes eszközök/GPU között elosztott kötegek összege. Ha az ml.g4dn.xlarge példány helyett egy elosztott betanítású ml.g16dn.4xlarge-t használunk, akkor nyolcszor annyi memóriánk van (8 GPU), mint egy ml.g4dn.xlarge példány (1 GPU). Az eszközenkénti kötegméret változatlan marad, de nyolc eszköz párhuzamosan oktat.

A SageMakernél megszokott módon létrehozunk a train.py script a Script móddal való használatra, és hiperparamétereket ad át a képzéshez. A következő Pegasus kódrészlet betölti a modellt és betanítja a Transformers segítségével Trainer osztály:

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

A teljes kód elérhető a GitHub.

Telepítse a betanított Hugging Face modellt a SageMakerben

Barátaink a Hugging Face-nél egyszerűbb következtetéseket vontak le a SageMaker for Transformers modellekről, köszönhetően a SageMaker Hugging Face Inference Toolkit. A környezeti változó egyszerű beállításával közvetlenül telepítheti a korábban betanított modellt "HF_TASK":"summarization" (az utasításokat lásd Pegasus modellek), választva Telepítése, majd válassza ki Amazon SageMaker, anélkül, hogy következtetési szkriptet kellene írnia.

Ha azonban valamilyen konkrét módszerre van szüksége az előrejelzések generálására vagy utófeldolgozására, például több összefoglaló javaslat generálására különböző szöveggenerálási paraméterek listája alapján, a saját következtetési szkript megírása hasznos és viszonylag egyszerű lehet:

# 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

Amint az az előző kódban látható, a HuggingFace ilyen következtetési szkriptjéhez a SageMakeren csak a következő sablonfunkciókra van szüksége:

• model_fn() – Beolvassa a bent lévő betanítási munka végén elmentettek tartalmát SM_MODEL_DIR, vagy egy meglévő, tar.gz fájlként elmentett modellsúlyok könyvtárból Amazon egyszerű tárolási szolgáltatás (Amazon S3). A betanított modell és a kapcsolódó tokenizátor betöltésére szolgál.
• input_fn() – Formázza a végponthoz intézett kérésből kapott adatokat.
• előre_fn() – Meghívja a kimenetét model_fn() (a modell és a tokenizátor), hogy következtetést lehessen levonni a kimenetére input_fn() (a formázott adatok).

Opcionálisan létrehozhat egy output_fn() függvény a következtetés formázásához, a kimenetének felhasználásával predict_fn(), amit ebben a bejegyzésben nem mutattunk be.

Ezután telepíthetjük a betanított Hugging Face modellt a hozzá tartozó következtetési szkripttel a SageMakerben a Átölelő arc SageMaker modell osztály:

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

Tesztelje a telepített modellt

Ehhez a demóhoz a modellt a Női e-kereskedelmi ruházati vélemények adatkészlet, amely ruházati cikkek ismertetőit (amelyeket bemeneti szövegnek tekintünk) és a hozzájuk tartozó címeket (amelyeket összefoglalónak tekintünk) tartalmazza. Miután eltávolítottuk a hiányzó címekkel rendelkező cikkeket, az adatkészlet 19,675 70 véleményt tartalmaz. A Pegasus modell finomhangolása a cikkek 3.5%-át tartalmazó oktatókészleten öt korszakra körülbelül 3.16 órát vett igénybe egy ml.pXNUMXxnagy példányon.

Ezután telepíthetjük a modellt, és tesztelhetjük a tesztkészletből származó példaadatokkal. A következő példa egy pulóver leírását tartalmazza:

# 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

A SageMaker végpontban tárolt egyéni következtetési szkriptünknek köszönhetően több összefoglalót készíthetünk ehhez az áttekintéshez különböző szöveggenerálási paraméterekkel. Például megkérhetjük a végpontot, hogy generáljon egy sor nagyon rövid vagy közepesen hosszú összegzést, amelyek különböző hosszúságú büntetéseket határoznak meg (minél kisebb a hosszúságú büntetés, annál rövidebb a generált összegzés). Íme néhány példa a paraméterbevitelre, és az azt követő, géppel generált összefoglalók:

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

Melyik összefoglalót részesíti előnyben? Az első generált cím negyedannyi szóval rögzíti az összes fontos tényt a felülvizsgálatról. Ezzel szemben az utolsó csak három szót használ (kevesebb, mint 1/10-ed az eredeti ismertető hosszának), hogy a pulóver legfontosabb jellemzőjére összpontosítson.

Következtetés

Finomhangolhat egy szöveges összefoglalót az egyéni adatkészletén, és üzembe helyezheti azt a SageMaker éles verziójában ezzel az egyszerű példával, amely elérhető a következő webhelyen: GitHub. További mintafüzetek a Hugging Face modellek betanítására és telepítésére a SageMakeren is elérhetők.

Mint mindig, az AWS szívesen fogadja a visszajelzéseket. Kérjük, tegye meg észrevételeit vagy kérdéseit.

Referenciák

[1] PEGASUS: Előképzés kivont hézagmondatokkal az absztrakt összefoglaláshoz

A szerzőkről

Viktor Malesevic gépi tanulási mérnök AWS professzionális szolgáltatásokkal, szenvedélyes a természetes nyelvi feldolgozás és az MLOp iránt. Együttműködik az ügyfelekkel a kihívást jelentő mély tanulási modellek fejlesztésén és AWS-en való gyártásban. Szabadidejében szívesen megoszt egy pohár vörösbort és egy kis sajtot a barátaival.

Aamna Najmi az AWS professzionális szolgáltatásokkal foglalkozó adattudós. Szenvedélyesen támogatja ügyfeleit a Big Data és a mesterséges intelligencia technológiákkal való innovációban, hogy üzleti értéket és betekintést nyerhessenek az adatokból. Szabadidejében szívesen kertészkedik és új helyekre utazik.