Ajustați și implementați un model de rezumat utilizând containerele Hugging Face Amazon SageMaker, aducându-vă propriul script

Au existat multe progrese recente în domeniul NLP. Modelele pre-instruite și serviciile NLP gestionate complet au democratizat accesul și adoptarea NLP. Amazon Comprehend este un serviciu complet gestionat care poate îndeplini sarcini NLP, cum ar fi recunoașterea personalizată a entităților, modelarea subiectelor, analiza sentimentelor și multe altele pentru a extrage informații din date fără a fi nevoie de vreo experiență anterioară de ML.

Anul trecut, AWS a anunțat un parteneriat cu Fata îmbrățișată pentru a ajuta la aducerea mai rapidă în producție a modelelor de procesare a limbajului natural (NLP). Hugging Face este o comunitate open-source AI, axată pe NLP. Biblioteca lor bazată pe Python (transformatoare) oferă instrumente pentru a utiliza cu ușurință arhitecturile populare Transformer de ultimă generație, cum ar fi BERT, RoBERTa și GPT. Puteți aplica aceste modele la o varietate de sarcini NLP, cum ar fi clasificarea textului, extragerea informațiilor și răspunsul la întrebări, printre alţii.

Amazon SageMaker este un serviciu complet gestionat care oferă dezvoltatorilor și cercetătorilor de date capacitatea de a construi, antrena și implementa rapid modele de învățare automată (ML). SageMaker elimină sarcinile grele din fiecare pas al procesului ML, facilitând dezvoltarea modelelor de înaltă calitate. SageMaker Python SDK oferă API-uri și containere open-source pentru a antrena și a implementa modele pe SageMaker, folosind mai multe cadre diferite de ML și de deep learning.

Integrarea Hugging Face cu SageMaker vă permite să construiți modele Hugging Face la scară pe propriile dvs. cazuri de utilizare specifice domeniului.

În această postare, vă prezentăm un exemplu despre cum să construiți și să implementați un rezumat personalizat de text Hugging Face pe SageMaker. În acest scop, folosim Pegasus [1], primul model bazat pe Transformer pre-antrenat în mod specific pe un obiectiv adaptat pentru rezumarea textului abstract. BERT este antrenat în prealabil pentru a masca cuvinte aleatorii într-o propoziție; în schimb, în ​​timpul pre-antrenamentului lui Pegasus, propozițiile sunt mascate dintr-un document de intrare. Modelul generează apoi propozițiile lipsă ca o singură secvență de ieșire folosind toate propozițiile nemascate ca context, creând ca rezultat un rezumat executiv al documentului.

Datorită flexibilității bibliotecii HuggingFace, puteți adapta cu ușurință codul afișat în această postare pentru alte tipuri de modele de transformatoare, cum ar fi t5, BART și altele.

Încărcați propriul set de date pentru a regla fin un model Hugging Face

Pentru a încărca un set de date personalizat dintr-un fișier CSV, folosim load_dataset metoda din pachetul Transformers. Putem aplica tokenizarea setului de date încărcat folosind datasets.Dataset.map funcţie. map funcția iterează peste setul de date încărcat și aplică funcția tokenize fiecărui exemplu. Setul de date tokenizat poate fi apoi transmis trainerului pentru reglarea fină a modelului. Vezi următorul cod:

# 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

Construiește-ți scriptul de antrenament pentru estimatorul Hugging Face SageMaker

După cum se explică în postare AWS și Hugging Face colaborează pentru a simplifica și accelera adoptarea modelelor de procesare a limbajului natural, antrenamentul unui model Hugging Face pe SageMaker nu a fost niciodată mai ușor. Putem face acest lucru utilizând estimatorul Hugging Face din SageMaker SDK.

Următorul fragment de cod ajustează Pegasus pe setul nostru de date. De asemenea, puteți găsi multe mostre de caiete care vă ghidează prin reglarea fină a diferitelor tipuri de modele, disponibile direct în depozitul transformers GitHub. Pentru a activa instruirea distribuită, putem folosi Biblioteca de paralelism de date în SageMaker, care a fost integrat în API-ul HuggingFace Trainer. Pentru a permite paralelismul datelor, trebuie să definim distribution parametrul în estimatorul nostru 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})

Dimensiunea maximă a lotului de antrenament pe care o puteți configura depinde de dimensiunea modelului și de memoria GPU a instanței utilizate. Dacă instruirea distribuită SageMaker este activată, dimensiunea totală a lotului este suma fiecărui lot care este distribuit pe fiecare dispozitiv/GPU. Dacă folosim un ml.g4dn.16xlarge cu antrenament distribuit în loc de o instanță ml.g4dn.xlarge, avem de opt ori (8 GPU-uri) mai multă memorie decât o instanță ml.g4dn.xlarge (1 GPU). Dimensiunea lotului per dispozitiv rămâne aceeași, dar opt dispozitive se antrenează în paralel.

Ca de obicei cu SageMaker, creăm un train.py script de utilizat cu Modul Script și treceți hiperparametri pentru antrenament. Următorul fragment de cod pentru Pegasus încarcă modelul și îl antrenează folosind Transformers Trainer clasă:

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

Codul complet este disponibil pe GitHub.

Implementați modelul instruit Hugging Face în SageMaker

Prietenii noștri de la Hugging Face au făcut inferențe cu privire la modelele SageMaker for Transformers mai simple decât oricând datorită SageMaker Hugging Face Inference Toolkit. Puteți implementa direct modelul antrenat anterior prin simpla setare a variabilei de mediu "HF_TASK":"summarization" (pentru instrucțiuni, vezi Modele Pegasus), alegând Lansa, iar apoi alegerea Amazon SageMaker, fără a fi nevoie să scrieți un script de inferență.

Cu toate acestea, dacă aveți nevoie de o modalitate specifică de a genera sau de a postprocesa predicții, de exemplu generarea mai multor sugestii rezumate bazate pe o listă de parametri diferiți de generare a textului, scrierea propriului script de inferență poate fi utilă și relativ simplă:

# 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

După cum se arată în codul precedent, un astfel de script de inferență pentru HuggingFace pe SageMaker are nevoie doar de următoarele funcții de șablon:

• model_fn() – Citește conținutul a ceea ce a fost salvat la sfârșitul jobului de formare în interior SM_MODEL_DIR, sau dintr-un director existent de greutăți de model salvat ca fișier tar.gz în Serviciul Amazon de stocare simplă (Amazon S3). Este folosit pentru a încărca modelul antrenat și tokenizerul asociat.
• input_fn() – Formatează datele primite de la o solicitare făcută către punctul final.
• predict_fn() – Apelează ieșirea de model_fn() (modelul și tokenizer) pentru a rula inferența asupra rezultatului input_fn() (datele formatate).

Opțional, puteți crea un output_fn() funcția de formatare a inferenței, folosind rezultatul de predict_fn(), ceea ce nu am demonstrat în această postare.

Apoi putem implementa modelul Hugging Face antrenat cu scriptul de inferență asociat la SageMaker folosind Față îmbrățișată Model SageMaker clasă:

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

Testați modelul implementat

Pentru această demonstrație, am antrenat modelul pe Set de date recenzii pentru îmbrăcăminte de comerț electronic pentru femei, care conține recenzii ale articolelor de îmbrăcăminte (pe care le considerăm text de intrare) și titlurile asociate acestora (pe care le considerăm rezumate). După ce eliminăm articolele cu titluri lipsă, setul de date conține 19,675 de recenzii. Reglarea fină a modelului Pegasus pe un set de antrenament care conținea 70% din acele articole timp de cinci epoci a durat aproximativ 3.5 ore pe o instanță ml.p3.16xlarge.

Apoi putem implementa modelul și îl putem testa cu câteva exemple de date din setul de testare. Următoarea este un exemplu de recenzie care descrie un 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

Datorită scriptului nostru de inferență personalizat găzduit într-un punct final SageMaker, putem genera mai multe rezumate pentru această revizuire cu diferiți parametri de generare de text. De exemplu, putem cere punctului final să genereze o gamă de rezumate foarte scurte până la moderat lungi care specifică penalizări de lungime diferite (cu cât penalitatea de lungime este mai mică, cu atât rezumatul generat este mai scurt). Următoarele sunt câteva exemple de introducere a parametrilor și rezumatele ulterioare generate de mașină:

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

Ce rezumat preferi? Primul titlu generat surprinde toate faptele importante despre recenzie, cu un sfert din numărul de cuvinte. În schimb, ultimul folosește doar trei cuvinte (mai puțin de 1/10 din lungimea recenziei originale) pentru a se concentra pe cea mai importantă caracteristică a puloverului.

Concluzie

Puteți ajusta un rezumat de text pe setul de date personalizat și îl puteți implementa în producție pe SageMaker cu acest exemplu simplu disponibil pe GitHub. Adiţional mostre de caiete pentru instruirea și implementarea modelelor Hugging Face pe SageMaker sunt, de asemenea, disponibile.

Ca întotdeauna, AWS salută feedback-ul. Vă rugăm să trimiteți orice comentarii sau întrebări.

Referinte

[1] PEGASUS: Pre-training cu extrase Gap-sentences pentru rezumat abstract

Despre autori

Viktor Malesevic este un inginer de învățare automată cu AWS Professional Services, pasionat de procesarea limbajului natural și MLOps. Lucrează cu clienții pentru a dezvolta și pune modele provocatoare de deep learning în producție pe AWS. În timpul liber, îi place să împartă cu prietenii un pahar de vin roșu și niște brânză.

Aamna Najmi este un Data Scientist cu AWS Professional Services. Este pasionată de a ajuta clienții să inoveze cu tehnologiile Big Data și Inteligența Artificială pentru a valorifica valoarea afacerii și informațiile din date. În timpul liber, îi place să facă grădinărit și să călătorească în locuri noi.