Sempurnakan dan terapkan model peringkas menggunakan wadah Hugging Face Amazon SageMaker yang membawa skrip Anda sendiri

Ada banyak kemajuan baru-baru ini dalam domain NLP. Model pra-terlatih dan layanan NLP yang terkelola sepenuhnya telah mendemokratisasi akses dan adopsi NLP. Amazon Comprehend adalah layanan terkelola sepenuhnya yang dapat melakukan tugas NLP seperti pengenalan entitas kustom, pemodelan topik, analisis sentimen, dan lainnya untuk mengekstrak wawasan dari data tanpa memerlukan pengalaman ML sebelumnya.

Tahun lalu, AWS mengumumkan persekutuan dengan Wajah Memeluk untuk membantu menghadirkan model pemrosesan bahasa alami (NLP) ke produksi lebih cepat. Hugging Face adalah komunitas AI open-source, yang berfokus pada NLP. Pustaka berbasis Python mereka (transformer) menyediakan alat untuk dengan mudah menggunakan arsitektur Transformer canggih yang populer seperti BERT, RoBERTa, dan GPT. Anda dapat menerapkan model ini ke berbagai tugas NLP, seperti klasifikasi teks, ekstraksi informasi, dan menjawab pertanyaan, di antaranya orang lain.

Amazon SageMaker adalah layanan terkelola sepenuhnya yang memberi pengembang dan ilmuwan data kemampuan untuk membangun, melatih, dan menerapkan model pembelajaran mesin (ML) dengan cepat. SageMaker menghilangkan beban berat dari setiap langkah proses ML, membuatnya lebih mudah untuk mengembangkan model berkualitas tinggi. SageMaker Python SDK menyediakan API dan container open-source untuk melatih dan menerapkan model di SageMaker, menggunakan beberapa kerangka kerja ML dan deep learning yang berbeda.

Integrasi Hugging Face dengan SageMaker memungkinkan Anda membuat model Hugging Face dalam skala besar pada kasus penggunaan khusus domain Anda sendiri.

Dalam posting ini, kami memandu Anda melalui contoh cara membuat dan menerapkan peringkas teks Wajah Memeluk khusus di SageMaker. Kami menggunakan Pegasus [1] untuk tujuan ini, model berbasis Transformer pertama yang secara khusus dilatih sebelumnya pada tujuan yang disesuaikan untuk peringkasan teks abstrak. BERT telah dilatih sebelumnya untuk menutupi kata-kata acak dalam sebuah kalimat; sebaliknya, selama pra-pelatihan Pegasus, kalimat disamarkan dari dokumen input. Model kemudian menghasilkan kalimat yang hilang sebagai satu urutan keluaran menggunakan semua kalimat yang tidak tertutup sebagai konteks, sebagai hasilnya membuat ringkasan eksekutif dokumen.

Berkat fleksibilitas perpustakaan HuggingFace, Anda dapat dengan mudah mengadaptasi kode yang ditampilkan dalam posting ini untuk jenis model transformator lainnya, seperti t5, BART, dan banyak lagi.

Muat dataset Anda sendiri untuk menyempurnakan model Hugging Face

Untuk memuat kumpulan data khusus dari file CSV, kami menggunakan: load_dataset metode dari paket Transformers. Kami dapat menerapkan tokenisasi ke kumpulan data yang dimuat menggunakan datasets.Dataset.map fungsi. Itu map fungsi berulang pada kumpulan data yang dimuat dan menerapkan fungsi tokenize ke setiap contoh. Dataset tokenized kemudian dapat diteruskan ke pelatih untuk menyempurnakan model. Lihat kode berikut:

# 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

Buat skrip pelatihan Anda untuk estimator Hugging Face SageMaker

Seperti yang dijelaskan dalam posting AWS dan Hugging Face berkolaborasi untuk menyederhanakan dan mempercepat adopsi model Pemrosesan Bahasa Alami, melatih model Wajah Memeluk di SageMaker tidak pernah semudah ini. Kita dapat melakukannya dengan menggunakan estimator Hugging Face dari SDK SageMaker.

Cuplikan kode berikut menyempurnakan Pegasus pada dataset kami. Anda juga dapat menemukan banyak buku catatan sampel yang memandu Anda dalam menyempurnakan berbagai jenis model, tersedia langsung di repositori GitHub transformer. Untuk mengaktifkan pelatihan terdistribusi, kita dapat menggunakan Perpustakaan Paralelisme Data di SageMaker, yang telah dibangun ke dalam HuggingFace Trainer API. Untuk mengaktifkan paralelisme data, kita perlu mendefinisikan: distribution parameter di estimator Hugging Face kami.

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

Ukuran batch pelatihan maksimum yang dapat Anda konfigurasikan bergantung pada ukuran model dan memori GPU dari instans yang digunakan. Jika pelatihan terdistribusi SageMaker diaktifkan, ukuran batch total adalah jumlah dari setiap batch yang didistribusikan di setiap perangkat/GPU. Jika kami menggunakan ml.g4dn.16xlarge dengan pelatihan terdistribusi, bukan instance ml.g4dn.xlarge, kami memiliki memori delapan kali (8 GPU) lebih banyak daripada instance ml.g4dn.xlarge (1 GPU). Ukuran batch per perangkat tetap sama, tetapi delapan perangkat dilatih secara paralel.

Seperti biasa dengan SageMaker, kami membuat train.py script untuk digunakan dengan Script Mode dan lulus hyperparameters untuk pelatihan. Cuplikan kode berikut untuk Pegasus memuat model dan melatihnya menggunakan Transformers Trainer kelas:

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

Kode lengkap tersedia di GitHub.

Terapkan model Wajah Memeluk yang terlatih ke SageMaker

Teman-teman kami di Hugging Face telah membuat inferensi pada model SageMaker untuk Transformers lebih sederhana dari sebelumnya berkat SageMaker Memeluk Alat Inferensi Wajah. Anda dapat langsung menerapkan model yang telah dilatih sebelumnya hanya dengan menyiapkan variabel lingkungan "HF_TASK":"summarization" (untuk petunjuk, lihat Model Pegasus), memilih Menyebarkan, lalu pilih Amazon SageMaker, tanpa perlu menulis skrip inferensi.

Namun, jika Anda memerlukan beberapa cara khusus untuk menghasilkan atau pascaproses prediksi, misalnya membuat beberapa saran ringkasan berdasarkan daftar parameter pembuatan teks yang berbeda, menulis skrip inferensi Anda sendiri dapat berguna dan relatif mudah:

# 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

Seperti yang ditunjukkan pada kode sebelumnya, skrip inferensi semacam itu untuk HuggingFace di SageMaker hanya memerlukan fungsi templat berikut:

• model_fn () – Membaca konten dari apa yang disimpan di akhir pekerjaan pelatihan di dalam SM_MODEL_DIR, atau dari direktori bobot model yang ada yang disimpan sebagai file tar.gz di Layanan Penyimpanan Sederhana Amazon (Amazon S3). Ini digunakan untuk memuat model terlatih dan tokenizer terkait.
• input_fn () – Memformat data yang diterima dari permintaan yang dibuat ke titik akhir.
• predict_fn () – Memanggil output dari model_fn() (model dan tokenizer) untuk menjalankan inferensi pada output dari input_fn() (data yang diformat).

Secara opsional, Anda dapat membuat output_fn() fungsi untuk pemformatan inferensi, menggunakan output dari predict_fn(), yang tidak kami tunjukkan dalam posting ini.

Kami kemudian dapat menerapkan model Wajah Memeluk yang terlatih dengan skrip inferensi terkait ke SageMaker menggunakan Memeluk Wajah Model SageMaker kelas:

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

Uji model yang digunakan

Untuk demo ini, kami melatih model di Dataset Ulasan Pakaian E-Commerce Wanita, yang berisi ulasan artikel pakaian (yang kami anggap sebagai teks masukan) dan judul terkait (yang kami anggap sebagai ringkasan). Setelah kami menghapus artikel dengan judul yang hilang, kumpulan data berisi 19,675 ulasan. Penyesuaian model Pegasus pada set pelatihan yang berisi 70% artikel tersebut selama lima zaman membutuhkan waktu sekitar 3.5 jam pada instans ml.p3.16xlarge.

Kami kemudian dapat menerapkan model dan mengujinya dengan beberapa contoh data dari set pengujian. Berikut ini adalah contoh review yang menjelaskan tentang sweater:

# 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

Berkat skrip inferensi khusus kami yang dihosting di titik akhir SageMaker, kami dapat membuat beberapa ringkasan untuk ulasan ini dengan parameter pembuatan teks yang berbeda. Misalnya, kita dapat meminta titik akhir untuk menghasilkan rentang ringkasan yang sangat pendek hingga cukup panjang yang menentukan penalti panjang yang berbeda (semakin kecil penalti panjang, semakin pendek ringkasan yang dihasilkan). Berikut ini adalah beberapa contoh input parameter, dan ringkasan yang dihasilkan mesin berikutnya:

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

Ringkasan mana yang Anda sukai? Judul yang dihasilkan pertama menangkap semua fakta penting tentang ulasan, dengan seperempat jumlah kata. Sebaliknya, yang terakhir hanya menggunakan tiga kata (kurang dari 1/10 panjang ulasan asli) untuk fokus pada fitur terpenting dari sweter.

Kesimpulan

Anda dapat menyempurnakan peringkas teks pada kumpulan data khusus Anda dan menerapkannya ke produksi di SageMaker dengan contoh sederhana ini tersedia di GitHub. Tambahan buku catatan sampel untuk melatih dan menerapkan model Wajah Memeluk di SageMaker juga tersedia.

Seperti biasa, AWS menyambut umpan balik. Silakan kirim komentar atau pertanyaan apa pun.

Referensi

[1] PEGASUS: Pra-pelatihan dengan Kalimat Celah yang Diekstraksi untuk Peringkasan Abstrak

Tentang penulis

Viktor Malesevic adalah Insinyur Pembelajaran Mesin dengan Layanan Profesional AWS, bersemangat tentang Pemrosesan Bahasa Alami dan MLOps. Dia bekerja dengan pelanggan untuk mengembangkan dan menerapkan model pembelajaran mendalam yang menantang ke produksi di AWS. Di waktu luangnya, ia menikmati berbagi segelas anggur merah dan keju dengan teman-temannya.

Aamna Najmi adalah Ilmuwan Data dengan Layanan Profesional AWS. Dia bersemangat membantu pelanggan berinovasi dengan teknologi Big Data dan Artificial Intelligence untuk memanfaatkan nilai bisnis dan wawasan dari data. Di waktu luangnya, dia suka berkebun dan bepergian ke tempat-tempat baru.