Kendi komut dosyanızı getiren Hugging Face Amazon SageMaker kapsayıcılarını kullanarak bir özetleyici modelinde ince ayar yapın ve dağıtın

NLP alanında son zamanlarda birçok gelişme olmuştur. Önceden eğitilmiş modeller ve tam olarak yönetilen NLP hizmetleri, NLP'nin erişimini ve benimsenmesini demokratikleştirmiştir. Amazon Kavramak özel varlık tanıma, konu modelleme, duygu analizi ve daha fazlası gibi NLP görevlerini gerçekleştirebilen ve önceden herhangi bir ML deneyimine ihtiyaç duymadan verilerden içgörüler elde edebilen tam olarak yönetilen bir hizmettir.

Geçen yıl, AWS bir ortaklık ile Sarılma Yüz doğal dil işleme (NLP) modellerinin üretime daha hızlı getirilmesine yardımcı olmak için. Hugging Face, NLP'ye odaklanan açık kaynaklı bir AI topluluğudur. Python tabanlı kütüphaneleri (Transformers), BERT, RoBERTa ve GPT gibi popüler son teknoloji Transformer mimarilerini kolayca kullanmak için araçlar sağlar. Bu modelleri metin sınıflandırma, bilgi çıkarma ve soru cevaplama gibi çeşitli NLP görevlerine uygulayabilirsiniz. diğerleri.

Amazon Adaçayı Yapıcı geliştiricilere ve veri bilimcilerine makine öğrenimi (ML) modellerini hızlı bir şekilde oluşturma, eğitme ve dağıtma yeteneği sağlayan tam olarak yönetilen bir hizmettir. SageMaker, makine öğrenimi sürecinin her adımındaki ağır yükleri ortadan kaldırarak yüksek kaliteli modeller geliştirmeyi kolaylaştırır. SageMaker Python SDK, birkaç farklı ML ve derin öğrenme çerçevesi kullanarak modelleri SageMaker'da eğitmek ve dağıtmak için açık kaynaklı API'ler ve kapsayıcılar sağlar.

SageMaker ile Hugging Face entegrasyonu, kendi etki alanına özgü kullanım durumlarınız için uygun ölçekte Hugging Face modelleri oluşturmanıza olanak tanır.

Bu gönderide, SageMaker'da özel bir Hugging Face metin özetleyicisinin nasıl oluşturulacağına ve dağıtılacağına dair bir örnekte size yol gösteriyoruz. Bu amaç için Pegasus [1] kullanıyoruz, soyutlayıcı metin özetleme için özel olarak hazırlanmış bir hedef üzerinde özel olarak önceden eğitilmiş ilk Transformer tabanlı model. BERT, bir cümlede rastgele sözcükleri maskeleme konusunda önceden eğitilmiştir; Buna karşılık, Pegasus'un ön eğitiminde, cümleler bir girdi belgesinden maskelenir. Ardından model, maskelenmemiş tüm cümleleri bağlam olarak kullanarak tek bir çıktı dizisi olarak eksik cümleleri oluşturur ve sonuç olarak belgenin bir yönetici özetini oluşturur.

HuggingFace kitaplığının esnekliği sayesinde, bu gönderide gösterilen kodu t5, BART ve daha fazlası gibi diğer transformatör modelleri için kolayca uyarlayabilirsiniz.

Hugging Face modelinde ince ayar yapmak için kendi veri kümenizi yükleyin

Bir CSV dosyasından özel bir veri kümesi yüklemek için load_dataset Transformers paketinden yöntem. Yüklenen veri kümesine belirteçleştirmeyi aşağıdakileri kullanarak uygulayabiliriz: datasets.Dataset.map işlevi. map function, yüklenen veri kümesi üzerinde yinelenir ve tokenize işlevini her örneğe uygular. Belirtilmiş veri kümesi daha sonra modelde ince ayar yapmak için eğiticiye iletilebilir. Aşağıdaki koda bakın:

# 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

Hugging Face SageMaker tahmincisi için eğitim komut dosyanızı oluşturun

Yazıda açıklandığı gibi AWS ve Hugging Face, Doğal Dil İşleme modellerinin benimsenmesini basitleştirmek ve hızlandırmak için işbirliği yapıyor, SageMaker'da Hugging Face modelini eğitmek hiç bu kadar kolay olmamıştı. Bunu, Hugging Face tahmincisini kullanarak yapabiliriz. Adaçayı Yapıcı SDK'sı.

Aşağıdaki kod parçacığı, veri kümemizde Pegasus'a ince ayar yapar. Ayrıca birçok bulabilirsiniz örnek defterler Bu, doğrudan transformatörlerin GitHub deposunda bulunan farklı model türlerinde ince ayar yapmanızda size rehberlik eder. Dağıtılmış eğitimi etkinleştirmek için kullanabiliriz Veri Paralellik Kitaplığı HuggingFace Trainer API'sinde yerleşik olarak bulunan SageMaker'da. Veri paralelliğini etkinleştirmek için şunları tanımlamamız gerekir: distribution Hugging Face tahmincimizdeki parametre.

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

Yapılandırabileceğiniz maksimum eğitim grubu boyutu, model boyutuna ve kullanılan örneğin GPU belleğine bağlıdır. SageMaker dağıtılmış eğitimi etkinleştirilirse, toplam toplu iş boyutu, her aygıt/GPU'ya dağıtılan her toplu işin toplamıdır. Bir ml.g4dn.xlarge örneği yerine dağıtılmış eğitime sahip bir ml.g16dn.4xlarge kullanırsak, bir ml.g8dn.xlarge örneğinin (4 GPU) sekiz katı (1 GPU) daha fazla belleğimiz olur. Cihaz başına parti boyutu aynı kalır, ancak sekiz cihaz paralel olarak eğitilir.

SageMaker ile her zamanki gibi, bir train.py Komut Dosyası Modu ile kullanılacak komut dosyası ve eğitim için hiperparametreler geçirin. Pegasus için aşağıdaki kod parçacığı modeli yükler ve Transformers'ı kullanarak eğitir Trainer sınıf:

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

Tam kod şu adreste mevcuttur: GitHub.

Eğitimli Hugging Face modelini SageMaker'a dağıtın

Hugging Face'deki arkadaşlarımız, SageMaker for Transformers modelleri üzerinde, SageMaker Kucaklayan Yüz Çıkarım Araç Seti. Ortam değişkenini ayarlayarak önceden eğitilmiş modeli doğrudan dağıtabilirsiniz. "HF_TASK":"summarization" (talimatlar için bkz. Pegasus Modelleri), seçme Sürüşve ardından seçim Amazon Adaçayı Yapıcı, bir çıkarım komut dosyası yazmaya gerek kalmadan.

Bununla birlikte, örneğin, farklı metin oluşturma parametrelerinin bir listesine dayalı olarak birkaç özet önerisi oluşturmak gibi, tahminler oluşturmak veya sonradan işlemek için belirli bir yola ihtiyacınız varsa, kendi çıkarım komut dosyanızı yazmak yararlı ve nispeten basit olabilir:

# 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

Önceki kodda gösterildiği gibi, SageMaker'da HuggingFace için böyle bir çıkarım betiği yalnızca aşağıdaki şablon işlevlerine ihtiyaç duyar:

• model_fn() – İçerideki eğitim işinin sonunda kaydedilenlerin içeriğini okur SM_MODEL_DIRveya tar.gz dosyası olarak kaydedilmiş mevcut bir model ağırlıkları dizininden Amazon Basit Depolama Hizmeti (Amazon S3). Eğitilmiş modeli ve ilişkili belirteci yüklemek için kullanılır.
• input_fn () – Uç noktaya yapılan bir istekten alınan verileri biçimlendirir.
• predict_fn () – çıkışını çağırır model_fn() (model ve belirteç) çıktısı üzerinde çıkarım yapmak için input_fn() (biçimlendirilmiş veriler).

İsteğe bağlı olarak, bir output_fn() çıktısını kullanarak çıkarım biçimlendirme işlevi predict_fn(), ki bu yazıda göstermedik.

Daha sonra, eğitimli Hugging Face modelini, ilişkili çıkarım komut dosyasıyla birlikte kullanarak SageMaker'a dağıtabiliriz. Sarılma Yüz SageMaker Modeli sınıf:

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

Dağıtılan modeli test edin

Bu demo için modeli şu konuda eğittik: Kadın E-Ticaret Giyim İncelemeleri veri seti, giyim makalelerinin (girdi metni olarak kabul ettiğimiz) incelemelerini ve bunlarla ilişkili başlıklarını (özet olarak değerlendirdiğimiz) içerir. Eksik başlıkları olan makaleleri çıkardıktan sonra, veri kümesi 19,675 inceleme içeriyor. Bu makalelerin %70'ini içeren bir eğitim setinde Pegasus modeline beş dönem için ince ayar yapmak, ml.p3.5xlarge örneği üzerinde yaklaşık 3.16 saat sürdü.

Daha sonra modeli konuşlandırabilir ve test setinden bazı örnek verilerle test edebiliriz. Aşağıdaki, bir süveteri anlatan örnek bir incelemedir:

# 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

Bir SageMaker uç noktasında barındırılan özel çıkarım komut dosyamız sayesinde, bu inceleme için farklı metin oluşturma parametreleriyle birkaç özet oluşturabiliriz. Örneğin, uç noktadan farklı uzunluk cezaları belirten çok kısa ila orta uzunlukta özetler aralığı oluşturmasını isteyebiliriz (uzunluk cezası ne kadar küçükse, oluşturulan özet o kadar kısa olur). Aşağıda bazı parametre girişi örnekleri ve ardından makine tarafından oluşturulan özetler verilmiştir:

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

Hangi özeti tercih edersiniz? İlk oluşturulan başlık, kelime sayısının dörtte biri ile inceleme hakkındaki tüm önemli gerçekleri yakalar. Buna karşılık, sonuncusu, süveterin en önemli özelliğine odaklanmak için yalnızca üç kelime (orijinal incelemenin uzunluğunun 1/10'undan daha az) kullanır.

Sonuç

Özel veri kümenizde bir metin özetleyiciye ince ayar yapabilir ve şu adreste bulunan bu basit örnekle SageMaker'da üretime dağıtabilirsiniz. GitHub. Ek örnek defterler SageMaker üzerinde Hugging Face modellerini eğitmek ve dağıtmak için de mevcuttur.

Her zaman olduğu gibi, AWS geri bildirimleri memnuniyetle karşılar. Lütfen herhangi bir yorum veya soru gönderin.

Referanslar

[1] PEGASUS: Soyutlayıcı Özetleme için Çıkarılmış Boşluk Cümleleri ile Ön Eğitim

yazarlar hakkında

Viktor Maleseviç AWS Profesyonel Hizmetlerine sahip, Doğal Dil İşleme ve MLOps konusunda tutkulu bir Makine Öğrenimi Mühendisidir. Zorlu derin öğrenme modelleri geliştirmek ve AWS'de üretime geçirmek için müşterilerle birlikte çalışır. Boş zamanlarında arkadaşlarıyla bir kadeh kırmızı şarap ve biraz peynir paylaşmaktan hoşlanır.

Aamna Necmi AWS Professional Services ile bir Veri Bilimcisidir. Verilerden iş değeri ve içgörülerden yararlanmak için müşterilerin Büyük Veri ve Yapay Zeka teknolojileriyle yenilik yapmasına yardımcı olma konusunda tutkulu. Boş zamanlarında bahçe işleri yapmaktan ve yeni yerlere seyahat etmekten hoşlanır.