ปรับแต่งและปรับใช้โมเดลตัวสรุปโดยใช้คอนเทนเนอร์ Hugging Face Amazon SageMaker ที่นำสคริปต์ของคุณเอง

มีความก้าวหน้าหลายอย่างในโดเมน NLP โมเดลที่ได้รับการฝึกอบรมล่วงหน้าและบริการ NLP ที่มีการจัดการเต็มรูปแบบมีการเข้าถึงและการนำ NLP ไปใช้ในระบอบประชาธิปไตย เข้าใจ Amazon เป็นบริการที่มีการจัดการเต็มรูปแบบซึ่งทำงาน NLP ได้ เช่น การรู้จำเอนทิตีแบบกำหนดเอง การสร้างแบบจำลองหัวข้อ การวิเคราะห์ความคิดเห็น และอื่นๆ เพื่อดึงข้อมูลเชิงลึกจากข้อมูลโดยไม่จำเป็นต้องมีประสบการณ์ ML มาก่อน

ปีที่แล้ว AWS ได้ประกาศ a ห้างหุ้นส่วน กับ กอดหน้า เพื่อช่วยนำแบบจำลองการประมวลผลภาษาธรรมชาติ (NLP) ไปสู่การผลิตได้รวดเร็วยิ่งขึ้น Hugging Face เป็นชุมชน AI แบบโอเพนซอร์สที่เน้นไปที่ NLP ไลบรารีที่ใช้ Python ของพวกเขา (หม้อแปลง) จัดเตรียมเครื่องมือเพื่อใช้สถาปัตยกรรม Transformer อันล้ำสมัยยอดนิยมอย่าง BERT, RoBERTa และ GPT ได้อย่างง่ายดาย คุณสามารถใช้แบบจำลองเหล่านี้กับงาน NLP ต่างๆ ได้ เช่น การจัดประเภทข้อความ การดึงข้อมูล และการตอบคำถาม คนอื่น ๆ.

อเมซอน SageMaker เป็นบริการที่มีการจัดการเต็มรูปแบบซึ่งให้นักพัฒนาและนักวิทยาศาสตร์ข้อมูลสามารถสร้าง ฝึกอบรม และปรับใช้โมเดลการเรียนรู้ของเครื่อง (ML) ได้อย่างรวดเร็ว SageMaker ขจัดการยกของหนักออกจากแต่ละขั้นตอนของกระบวนการ ML ทำให้ง่ายต่อการพัฒนาโมเดลคุณภาพสูง SageMaker Python SDK จัดเตรียม API แบบโอเพนซอร์สและคอนเทนเนอร์สำหรับฝึกและปรับใช้โมเดลบน SageMaker โดยใช้ ML ที่แตกต่างกันหลายแบบและเฟรมเวิร์กการเรียนรู้เชิงลึก

การผสานรวม Hugging Face กับ SageMaker ช่วยให้คุณสร้างโมเดล Hugging Face ได้ตามขนาดกรณีการใช้งานเฉพาะโดเมนของคุณเอง

ในโพสต์นี้ เราจะแนะนำคุณเกี่ยวกับตัวอย่างวิธีสร้างและปรับใช้โปรแกรมสรุปข้อความ Hugging Face แบบกำหนดเองบน SageMaker เราใช้ Pegasus [1] เพื่อจุดประสงค์นี้ ซึ่งเป็นโมเดล Transformer ตัวแรกที่ได้รับการฝึกฝนมาล่วงหน้าโดยเฉพาะตามวัตถุประสงค์ที่ได้รับการปรับแต่งสำหรับการสรุปข้อความที่เป็นนามธรรม BERT ได้รับการฝึกอบรมล่วงหน้าเกี่ยวกับการปิดบังคำแบบสุ่มในประโยค ในทางตรงกันข้าม ในระหว่างการฝึกก่อนการฝึกของเพกาซัส ประโยคจะถูกปิดบังจากเอกสารป้อนข้อมูล จากนั้น โมเดลจะสร้างประโยคที่หายไปเป็นลำดับเอาต์พุตเดียวโดยใช้ประโยคที่ไม่ได้มาสก์ทั้งหมดเป็นบริบท ทำให้เกิดบทสรุปสำหรับผู้บริหารของเอกสาร

ด้วยความยืดหยุ่นของไลบรารี HuggingFace คุณจึงสามารถปรับโค้ดที่แสดงในโพสต์นี้สำหรับหม้อแปลงรุ่นอื่นๆ ได้อย่างง่ายดาย เช่น t5, BART และอื่นๆ

โหลดชุดข้อมูลของคุณเองเพื่อปรับแต่งโมเดล Hugging Face

ในการโหลดชุดข้อมูลที่กำหนดเองจากไฟล์ CSV เราใช้ load_dataset วิธีการจากแพ็คเกจ Transformers เราสามารถใช้ tokenization กับชุดข้อมูลที่โหลดได้โดยใช้คำสั่ง datasets.Dataset.map ฟังก์ชัน map ฟังก์ชันจะวนซ้ำชุดข้อมูลที่โหลดและใช้ฟังก์ชัน tokenize กับแต่ละตัวอย่าง จากนั้นชุดข้อมูลที่เป็นโทเค็นจะถูกส่งต่อไปยังผู้ฝึกสอนเพื่อปรับแต่งโมเดลอย่างละเอียด ดูรหัสต่อไปนี้:

# 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

ตามที่อธิบายไว้ในโพสต์ AWS และ Hugging Face ร่วมมือกันเพื่อลดความซับซ้อนและเร่งการนำโมเดลการประมวลผลภาษาธรรมชาติมาใช้การฝึกโมเดล Hugging Face บน SageMaker ง่ายกว่าที่เคย เราสามารถทำได้โดยใช้ตัวประมาณการกอดใบหน้าจาก SDK ของ SageMaker.

ข้อมูลโค้ดต่อไปนี้จะปรับแต่ง Pegasus บนชุดข้อมูลของเรา นอกจากนี้คุณยังสามารถหาได้มากมาย โน๊ตบุ๊คตัวอย่าง ที่จะแนะนำคุณเกี่ยวกับการปรับแต่งรุ่นต่างๆ อย่างละเอียด ซึ่งมีอยู่ในคลังเก็บ GitHub ของ Transformer โดยตรง เพื่อเปิดใช้งานการฝึกอบรมแบบกระจาย เราสามารถใช้ ไลบรารีข้อมูลแบบขนาน ใน SageMaker ซึ่งสร้างไว้ใน HuggingFace Trainer API ในการทำให้ข้อมูลมีความขนานกัน เราต้องกำหนด distribution พารามิเตอร์ในตัวประมาณการกอดใบหน้าของเรา

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

ขนาดชุดการฝึกสูงสุดที่คุณสามารถกำหนดค่าได้ขึ้นอยู่กับขนาดรุ่นและหน่วยความจำ GPU ของอินสแตนซ์ที่ใช้ หากเปิดใช้งานการฝึกแบบกระจาย SageMaker ขนาดแบตช์ทั้งหมดคือผลรวมของทุกแบตช์ที่แจกจ่ายไปยังอุปกรณ์/GPU แต่ละตัว หากเราใช้ ml.g4dn.16xlarge กับการฝึกอบรมแบบกระจายแทนอินสแตนซ์ ml.g4dn.xlarge เรามีหน่วยความจำแปดเท่า (8 GPU) เท่ากับอินสแตนซ์ ml.g4dn.xlarge (1 GPU) ขนาดแบทช์ต่ออุปกรณ์ยังคงเท่าเดิม แต่อุปกรณ์แปดเครื่องกำลังฝึกแบบขนานกัน

ตามปกติกับ SageMaker เราสร้าง a train.py สคริปต์เพื่อใช้กับโหมดสคริปต์และส่งผ่านไฮเปอร์พารามิเตอร์สำหรับการฝึก ข้อมูลโค้ดต่อไปนี้สำหรับ Pegasus จะโหลดโมเดลและฝึกฝนโดยใช้ Transformers Trainer ระดับ:

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

รหัสเต็มสามารถดูได้ที่ GitHub.

ปรับใช้โมเดล Hugging Face ที่ผ่านการฝึกอบรมกับ SageMaker

เพื่อนของเราที่ Hugging Face ได้สรุปเกี่ยวกับ SageMaker สำหรับโมเดล Transformers ได้ง่ายกว่าที่เคยด้วย ชุดเครื่องมืออนุมานใบหน้ากอด SageMaker. คุณสามารถปรับใช้โมเดลที่ฝึกก่อนหน้านี้ได้โดยตรงโดยเพียงแค่ตั้งค่าตัวแปรสภาพแวดล้อม "HF_TASK":"summarization" (ดูคำแนะนำได้ที่ รุ่น Pegasus) กำลังเลือก ปรับใช้แล้วเลือก อเมซอน SageMakerโดยไม่ต้องเขียนสคริปต์อนุมาน

อย่างไรก็ตาม หากคุณต้องการวิธีเฉพาะในการสร้างหรือการคาดคะเนภายหลังการประมวลผล เช่น การสร้างคำแนะนำสรุปหลายรายการตามรายการพารามิเตอร์การสร้างข้อความต่างๆ การเขียนสคริปต์การอนุมานของคุณเองอาจมีประโยชน์และค่อนข้างตรงไปตรงมา:

# 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

ตามที่แสดงในโค้ดก่อนหน้านี้ สคริปต์อนุมานดังกล่าวสำหรับ HuggingFace บน SageMaker ต้องการเพียงฟังก์ชันเทมเพลตต่อไปนี้เท่านั้น:

• model_fn() – อ่านเนื้อหาของสิ่งที่บันทึกไว้เมื่อสิ้นสุดงานการฝึกอบรมภายใน SM_MODEL_DIRหรือจากไดเร็กทอรีน้ำหนักโมเดลที่มีอยู่ซึ่งบันทึกเป็นไฟล์ tar.gz ใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (อเมซอน เอส3). ใช้เพื่อโหลดโมเดลที่ได้รับการฝึกและโทเค็นไลเซอร์ที่เกี่ยวข้อง
• input_fn() – จัดรูปแบบข้อมูลที่ได้รับจากการร้องขอไปยังปลายทาง
• ทำนาย_fn() – เรียกผลลัพธ์ของ model_fn() (ตัวแบบและตัวสร้างโทเค็น) เพื่อทำการอนุมานผลลัพธ์ของ input_fn() (ข้อมูลที่จัดรูปแบบ)

คุณสามารถเลือกสร้าง an output_fn() ฟังก์ชันสำหรับการจัดรูปแบบการอนุมาน โดยใช้ผลลัพธ์ของ predict_fn()ซึ่งเราไม่ได้แสดงให้เห็นในโพสต์นี้

จากนั้นเราสามารถปรับใช้โมเดล Hugging Face ที่ผ่านการฝึกอบรมด้วยสคริปต์อนุมานที่เชื่อมโยงกับ SageMaker โดยใช้ กอดใบหน้า SageMaker รุ่น ระดับ:

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

ทดสอบโมเดลที่ปรับใช้

สำหรับการสาธิตนี้ เราได้ฝึกโมเดลเกี่ยวกับ ชุดข้อมูลรีวิวเสื้อผ้าอีคอมเมิร์ซของผู้หญิงซึ่งมีบทวิจารณ์บทความเกี่ยวกับเสื้อผ้า (ซึ่งเราถือว่าเป็นข้อความป้อนเข้า) และชื่อที่เกี่ยวข้อง (ซึ่งเราถือว่าเป็นบทสรุป) หลังจากที่เราลบบทความที่ไม่มีชื่อแล้ว ชุดข้อมูลจะมีบทวิจารณ์ 19,675 รายการ การปรับแต่งโมเดล Pegasus อย่างละเอียดในชุดการฝึกที่มี 70% ของบทความเหล่านั้นสำหรับห้ายุคใช้เวลาประมาณ 3.5 ชั่วโมงในอินสแตนซ์ ml.p3.16xlarge

จากนั้นเราสามารถปรับใช้โมเดลและทดสอบด้วยข้อมูลตัวอย่างบางส่วนจากชุดทดสอบ ต่อไปนี้คือตัวอย่างบทวิจารณ์ที่อธิบายเสื้อกันหนาว:

# 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

ต้องขอบคุณสคริปต์การอนุมานแบบกำหนดเองของเราที่โฮสต์อยู่ในจุดสิ้นสุด SageMaker เราจึงสามารถสร้างสรุปหลายรายการสำหรับการตรวจทานนี้ด้วยพารามิเตอร์การสร้างข้อความที่แตกต่างกัน ตัวอย่างเช่น เราสามารถขอให้ปลายทางสร้างช่วงของบทสรุปสั้นมากถึงยาวปานกลางที่ระบุบทลงโทษด้านความยาวที่แตกต่างกัน ต่อไปนี้คือตัวอย่างอินพุตพารามิเตอร์บางส่วน และข้อมูลสรุปที่สร้างโดยเครื่องในภายหลัง:

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

สรุปแบบไหนที่คุณชอบ? ชื่อที่สร้างขึ้นครั้งแรกจะรวบรวมข้อเท็จจริงที่สำคัญทั้งหมดเกี่ยวกับบทวิจารณ์ โดยคิดเป็นหนึ่งในสี่ของจำนวนคำ ในทางตรงกันข้าม คำสุดท้ายใช้เพียงสามคำ (น้อยกว่า 1 ใน 10 ของบทวิจารณ์ต้นฉบับ) เพื่อเน้นที่คุณลักษณะที่สำคัญที่สุดของเสื้อสเวตเตอร์

สรุป

คุณสามารถปรับแต่งตัวสรุปข้อความบนชุดข้อมูลที่กำหนดเองของคุณ และปรับใช้กับการใช้งานจริงบน SageMaker ด้วยตัวอย่างง่ายๆ ที่มีอยู่ใน GitHub. เพิ่มเติม โน๊ตบุ๊คตัวอย่าง เพื่อฝึกฝนและปรับใช้โมเดล Hugging Face บน SageMaker ได้ด้วย

เช่นเคย AWS ยินดีรับข้อเสนอแนะ กรุณาส่งความคิดเห็นหรือคำถามใด ๆ

อ้างอิง

[1] PEGASUS: การฝึกอบรมล่วงหน้าด้วยการแยกประโยคสำหรับการสรุปเชิงนามธรรม

เกี่ยวกับผู้แต่ง

วิคเตอร์ มาเลเซวิช เป็นวิศวกรแมชชีนเลิร์นนิ่งที่มีบริการระดับมืออาชีพของ AWS ซึ่งหลงใหลในการประมวลผลภาษาธรรมชาติและ MLOps เขาทำงานร่วมกับลูกค้าเพื่อพัฒนาและนำโมเดลการเรียนรู้เชิงลึกที่ท้าทายมาสู่การผลิตบน AWS ในเวลาว่าง เขาชอบดื่มไวน์แดงและชีสกับเพื่อนๆ

อามนะ นัจมี เป็นนักวิทยาศาสตร์ข้อมูลที่มี AWS Professional Services เธอมีความกระตือรือร้นในการช่วยลูกค้าสร้างสรรค์นวัตกรรมด้วยเทคโนโลยี Big Data และปัญญาประดิษฐ์ เพื่อดึงมูลค่าทางธุรกิจและข้อมูลเชิงลึกจากข้อมูล ในเวลาว่าง เธอชอบทำสวนและเดินทางไปยังสถานที่ใหม่ๆ