Dostosuj i wdróż model podsumowania za pomocą kontenerów Hugging Face Amazon SageMaker, które przynoszą własny skrypt

W dziedzinie NLP nastąpiło ostatnio wiele postępów. Wstępnie wytrenowane modele i w pełni zarządzane usługi NLP zdemokratyzowały dostęp i przyjęcie NLP. Amazon Comprehend to w pełni zarządzana usługa, która może wykonywać zadania NLP, takie jak rozpoznawanie niestandardowych jednostek, modelowanie tematów, analiza sentymentu i nie tylko, aby wyodrębniać spostrzeżenia z danych bez konieczności wcześniejszego doświadczenia z ML.

W zeszłym roku AWS ogłosiło współpraca w Przytulanie Twarzy aby przyspieszyć produkcję modeli przetwarzania języka naturalnego (NLP). Hugging Face to społeczność AI o otwartym kodzie źródłowym, skupiona na NLP. Ich biblioteka oparta na Pythonie (Transformatory) udostępnia narzędzia do łatwego korzystania z popularnych, najnowocześniejszych architektur Transformer, takich jak BERT, RoBERTa i GPT. Możesz zastosować te modele do różnych zadań NLP, takich jak klasyfikacja tekstu, wyodrębnianie informacji i odpowiadanie na pytania, m.in inni.

Amazon Sage Maker to w pełni zarządzana usługa, która zapewnia programistom i analitykom danych możliwość szybkiego tworzenia, trenowania i wdrażania modeli uczenia maszynowego (ML). SageMaker eliminuje konieczność podnoszenia ciężarów na każdym etapie procesu ML, ułatwiając tworzenie modeli wysokiej jakości. SageMaker Python SDK udostępnia interfejsy API i kontenery typu open source do trenowania i wdrażania modeli w programie SageMaker przy użyciu kilku różnych platform uczenia maszynowego i głębokiego uczenia się.

Integracja Hugging Face z programem SageMaker umożliwia budowanie modeli Hugging Face na dużą skalę we własnych przypadkach użycia specyficznych dla domeny.

W tym poście przeprowadzimy Cię przez przykład, jak zbudować i wdrożyć niestandardowe podsumowanie tekstu Hugging Face w SageMakerze. W tym celu używamy Pegasusa [1], pierwszego modelu opartego na transformatorze, specjalnie wstępnie wytrenowanego na celu dostosowanym do abstrakcyjnego podsumowania tekstu. BERT jest wstępnie przeszkolony w maskowaniu przypadkowych słów w zdaniu; w przeciwieństwie do tego, podczas wstępnego treningu Pegasusa, zdania są maskowane z dokumentu wejściowego. Model następnie generuje brakujące zdania jako pojedynczą sekwencję wyjściową, używając wszystkich niezamaskowanych zdań jako kontekstu, tworząc w rezultacie streszczenie dokumentu.

Dzięki elastyczności biblioteki HuggingFace możesz łatwo dostosować kod przedstawiony w tym poście do innych typów modeli transformatorów, takich jak t5, BART i innych.

Załaduj własny zestaw danych, aby dostroić model Przytulonej twarzy

Aby załadować niestandardowy zbiór danych z pliku CSV, używamy load_dataset metoda z pakietu Transformers. Możemy zastosować tokenizację do załadowanego zbioru danych za pomocą datasets.Dataset.map funkcjonować. The map funkcja iteruje po załadowanym zestawie danych i stosuje funkcję tokenizacji do każdego przykładu. Stokenizowany zestaw danych można następnie przekazać trenerowi w celu dostrojenia modelu. Zobacz następujący kod:

# 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

Zbuduj swój skrypt szkoleniowy dla estymatora Hugging Face SageMaker

Jak wyjaśniono w poście AWS i Hugging Face współpracują, aby uprościć i przyspieszyć wdrażanie modeli przetwarzania języka naturalnego, trenowanie modelu Przytulanie twarzy w programie SageMaker nigdy nie było łatwiejsze. Możemy to zrobić, korzystając z estymatora Hugging Face z SDK SageMakera.

Poniższy fragment kodu dostraja Pegasusa w naszym zbiorze danych. Możesz też znaleźć wiele przykładowe zeszyty które poprowadzą Cię przez dostrajanie różnych typów modeli, dostępnych bezpośrednio w repozytorium transformatorów GitHub. Aby umożliwić rozproszone szkolenie, możemy użyć Biblioteka równoległości danych w SageMaker, który został wbudowany w interfejs API HuggingFace Trainer. Aby umożliwić równoległość danych, musimy zdefiniować distribution w naszym estymatorze Przytulanie twarzy.

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

Maksymalny rozmiar partii szkolenia, który można skonfigurować, zależy od rozmiaru modelu i pamięci GPU używanego wystąpienia. Jeśli szkolenie rozproszone SageMaker jest włączone, całkowity rozmiar partii jest sumą każdej partii, która jest dystrybuowana na każde urządzenie/GPU. Jeśli używamy ml.g4dn.16xlarge z rozproszonym szkoleniem zamiast wystąpienia ml.g4dn.xlarge, mamy osiem razy (8 GPU) więcej pamięci niż wystąpienie ml.g4dn.xlarge (1 GPU). Wielkość partii na urządzenie pozostaje taka sama, ale równolegle trenuje osiem urządzeń.

Jak zwykle w SageMakerze tworzymy train.py skrypt do użycia w trybie skryptu i przekazania hiperparametrów do szkolenia. Poniższy fragment kodu dla Pegasusa ładuje model i trenuje go za pomocą Transformers Trainer klasa:

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

Pełny kod jest dostępny na GitHub.

Wdróż wyszkolony model Przytulonej twarzy w SageMaker

Nasi przyjaciele z Hugging Face sprawili, że wnioskowanie na temat modeli SageMaker for Transformers stało się prostsze niż kiedykolwiek dzięki Zestaw narzędzi do wnioskowania o przytulaniu twarzy SageMaker. Możesz bezpośrednio wdrożyć wcześniej wyszkolony model, po prostu konfigurując zmienną środowiskową "HF_TASK":"summarization" (aby uzyskać instrukcje, zobacz Modele Pegasus), wybierając Rozmieścić, a następnie wybierając Amazon Sage Maker, bez konieczności pisania skryptu wnioskowania.

Jeśli jednak potrzebujesz określonego sposobu generowania lub przetwarzania prognoz, na przykład generowania kilku sugestii podsumowujących na podstawie listy różnych parametrów generowania tekstu, napisanie własnego skryptu wnioskowania może być przydatne i stosunkowo proste:

# 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

Jak pokazano w poprzednim kodzie, taki skrypt wnioskowania dla HuggingFace w SageMaker wymaga tylko następujących funkcji szablonu:

• model_fn () – Czyta treść tego, co zostało zapisane pod koniec pracy szkoleniowej w środku SM_MODEL_DIR, lub z istniejącego katalogu wag modelu zapisanego jako plik tar.gz w Usługa Amazon Simple Storage (Amazonka S3). Służy do ładowania wytrenowanego modelu i skojarzonego tokenizera.
• input_fn () – Formatuje dane otrzymane z żądania skierowanego do punktu końcowego.
• przewidywać_fn () – Wywołuje wyjście model_fn() (model i tokenizer), aby uruchomić wnioskowanie na wyjściu input_fn() (dane sformatowane).

Opcjonalnie możesz utworzyć output_fn() funkcja formatowania wnioskowania, wykorzystująca wyjście predict_fn(), czego nie pokazaliśmy w tym poście.

Następnie możemy wdrożyć wytrenowany model Przytulonej twarzy z powiązanym skryptem wnioskowania w programie SageMaker za pomocą Przytulanie twarzy model SageMaker klasa:

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

Przetestuj wdrożony model

W tym pokazie przeszkoliliśmy model na Zbiór danych recenzji odzieży dla kobiet w handlu elektronicznym, która zawiera recenzje artykułów odzieżowych (które traktujemy jako tekst wejściowy) i powiązane z nimi tytuły (które traktujemy jako streszczenia). Po usunięciu artykułów z brakującymi tytułami zbiór danych zawiera 19,675 70 recenzji. Dostrajanie modelu Pegasus na zbiorze uczącym zawierającym 3.5% tych artykułów dla pięciu epok zajęło około 3.16 godziny na instancji ml.pXNUMXxlarge.

Następnie możemy wdrożyć model i przetestować go na przykładowych danych z zestawu testowego. Poniżej znajduje się przykładowa recenzja opisująca sweter:

# 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

Dzięki naszemu niestandardowemu skryptowi wnioskowania hostowanemu w punkcie końcowym SageMaker możemy wygenerować kilka podsumowań dla tej recenzji z różnymi parametrami generowania tekstu. Na przykład możemy poprosić punkt końcowy o wygenerowanie zakresu bardzo krótkich do umiarkowanie długich podsumowań, określając różne kary za długość (im mniejsza kara za długość, tym krótsze wygenerowane podsumowanie). Poniżej przedstawiono kilka przykładów wprowadzania parametrów i kolejne podsumowania generowane przez maszynę:

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

Jakie podsumowanie wolisz? Pierwszy wygenerowany tytuł zawiera wszystkie ważne fakty dotyczące recenzji, a liczba słów to jedna czwarta. W przeciwieństwie do tego ostatnia używa tylko trzech słów (mniej niż 1/10 długości oryginalnej recenzji), aby skupić się na najważniejszej cesze swetra.

Wnioski

Możesz dostroić podsumowanie tekstu w swoim niestandardowym zestawie danych i wdrożyć go w środowisku produkcyjnym w SageMaker za pomocą tego prostego przykładu dostępnego na GitHub. Dodatkowy przykładowe zeszyty do trenowania i wdrażania modeli Hugging Face w programie SageMaker są również dostępne.

Jak zawsze, AWS chętnie przyjmuje opinie. Prosimy o przesyłanie wszelkich uwag lub pytań.

Referencje

[1] PEGASUS: Wstępne szkolenie z wydobytymi zdaniami na potrzeby abstrakcyjnego podsumowania

O autorach

Wiktor Malesević jest inżynierem uczenia maszynowego w AWS Professional Services, pasjonuje się przetwarzaniem języka naturalnego i MLOps. Współpracuje z klientami, aby opracowywać i wprowadzać do produkcji wymagające modele uczenia głębokiego w AWS. W wolnym czasie chętnie dzieli się z przyjaciółmi kieliszkiem czerwonego wina i serem.

Amna Najmi jest analitykiem danych w AWS Professional Services. Jej pasją jest pomaganie klientom w innowacjach dzięki technologiom Big Data i sztucznej inteligencji, aby wykorzystać wartość biznesową i wnioski z danych. W wolnym czasie lubi pracować w ogrodzie i podróżować do nowych miejsc.