हगिंग फेस अमेज़ॅन सेजमेकर कंटेनरों का उपयोग करके अपनी खुद की स्क्रिप्ट लाने के लिए एक सारांश मॉडल को फाइन-ट्यून और तैनात करें

एनएलपी डोमेन में हाल ही में कई प्रगति हुई है। पूर्व-प्रशिक्षित मॉडल और पूरी तरह से प्रबंधित एनएलपी सेवाओं ने एनएलपी की पहुंच और अपनाने का लोकतंत्रीकरण किया है। Amazon Comprehend एक पूरी तरह से प्रबंधित सेवा है जो किसी भी पूर्व एमएल अनुभव की आवश्यकता के बिना डेटा से अंतर्दृष्टि निकालने के लिए कस्टम इकाई मान्यता, विषय मॉडलिंग, भावना विश्लेषण और अधिक जैसे एनएलपी कार्य कर सकती है।

पिछले साल, एडब्ल्यूएस ने घोषणा की थी साझेदारी साथ में गले लगना प्राकृतिक भाषा प्रसंस्करण (एनएलपी) मॉडल को तेजी से उत्पादन में लाने में मदद करने के लिए। हगिंग फेस एक ओपन-सोर्स एआई समुदाय है, जो एनएलपी पर केंद्रित है। उनका पायथन-आधारित पुस्तकालय (ट्रान्सफ़ॉर्मर) लोकप्रिय अत्याधुनिक ट्रांसफॉर्मर आर्किटेक्चर जैसे BERT, RoBERta, और GPT का आसानी से उपयोग करने के लिए टूल प्रदान करता है। आप इन मॉडलों को विभिन्न प्रकार के एनएलपी कार्यों में लागू कर सकते हैं, जैसे पाठ वर्गीकरण, सूचना निष्कर्षण, और प्रश्न उत्तर, के बीच दूसरों.

अमेज़न SageMaker एक पूरी तरह से प्रबंधित सेवा है जो डेवलपर्स और डेटा वैज्ञानिकों को मशीन लर्निंग (एमएल) मॉडल को जल्दी से बनाने, प्रशिक्षित करने और तैनात करने की क्षमता प्रदान करती है। सेजमेकर एमएल प्रक्रिया के प्रत्येक चरण से भारी भारोत्तोलन को हटा देता है, जिससे उच्च गुणवत्ता वाले मॉडल विकसित करना आसान हो जाता है। सेजमेकर पायथन एसडीके कई अलग-अलग एमएल और डीप लर्निंग फ्रेमवर्क का उपयोग करके सेजमेकर पर मॉडल को प्रशिक्षित और तैनात करने के लिए ओपन-सोर्स एपीआई और कंटेनर प्रदान करता है।

सेजमेकर के साथ हगिंग फेस एकीकरण आपको अपने डोमेन-विशिष्ट उपयोग के मामलों में बड़े पैमाने पर हगिंग फेस मॉडल बनाने की अनुमति देता है।

इस पोस्ट में, हम आपको सेजमेकर पर एक कस्टम हगिंग फेस टेक्स्ट सारांश बनाने और तैनात करने के उदाहरण के माध्यम से चलते हैं। हम इस उद्देश्य के लिए पेगासस [1] का उपयोग करते हैं, पहला ट्रांसफार्मर-आधारित मॉडल विशेष रूप से अमूर्त पाठ सारांश के लिए तैयार किए गए उद्देश्य पर पूर्व-प्रशिक्षित। BERT एक वाक्य में यादृच्छिक शब्दों को छिपाने के लिए पूर्व-प्रशिक्षित है; इसके विपरीत, पेगासस के पूर्व-प्रशिक्षण के दौरान, वाक्यों को एक इनपुट दस्तावेज़ से छिपाया जाता है। मॉडल तब लापता वाक्यों को एक एकल आउटपुट अनुक्रम के रूप में उत्पन्न करता है, जो संदर्भ के रूप में सभी अनमास्क वाक्यों का उपयोग करता है, परिणामस्वरूप दस्तावेज़ का एक कार्यकारी सारांश बनाता है।

हगिंगफेस लाइब्रेरी के लचीलेपन के लिए धन्यवाद, आप इस पोस्ट में दिखाए गए कोड को अन्य प्रकार के ट्रांसफार्मर मॉडल, जैसे t5, BART, और बहुत कुछ के लिए आसानी से अनुकूलित कर सकते हैं।

हगिंग फेस मॉडल को फाइन-ट्यून करने के लिए अपना खुद का डेटासेट लोड करें

CSV फ़ाइल से कस्टम डेटासेट लोड करने के लिए, हम इसका उपयोग करते हैं load_dataset ट्रांसफॉर्मर पैकेज से विधि। हम लोड किए गए डेटासेट का उपयोग करके टोकननाइज़ेशन लागू कर सकते हैं datasets.Dataset.map समारोह। map फ़ंक्शन लोड किए गए डेटासेट पर पुनरावृति करता है और प्रत्येक उदाहरण के लिए टोकन फ़ंक्शन लागू करता है। फिर मॉडल को फाइन-ट्यूनिंग करने के लिए टोकन वाले डेटासेट को ट्रेनर को पास किया जा सकता है। निम्नलिखित कोड देखें:

# 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

हगिंग फेस सेजमेकर अनुमानक के लिए अपनी प्रशिक्षण स्क्रिप्ट बनाएं

जैसा कि पोस्ट में बताया गया है AWS और हगिंग फेस नेचुरल लैंग्वेज प्रोसेसिंग मॉडल को अपनाने को सरल और तेज करने के लिए सहयोग किया, सेजमेकर पर हगिंग फेस मॉडल को प्रशिक्षित करना इतना आसान कभी नहीं रहा। हम से हगिंग फेस अनुमानक का उपयोग करके ऐसा कर सकते हैं सेजमेकर एसडीके.

निम्नलिखित कोड स्निपेट हमारे डेटासेट पर पेगासस को फाइन-ट्यून्स करता है। आप भी कई पा सकते हैं नमूना नोटबुक जो आपको विभिन्न प्रकार के मॉडलों को फाइन-ट्यूनिंग के माध्यम से मार्गदर्शन करता है, जो सीधे ट्रांसफॉर्मर गिटहब रिपोजिटरी में उपलब्ध है। वितरित प्रशिक्षण को सक्षम करने के लिए, हम इसका उपयोग कर सकते हैं डेटा समानता पुस्तकालय सेजमेकर में, जिसे हगिंगफेस ट्रेनर एपीआई में बनाया गया है। डेटा समांतरता को सक्षम करने के लिए, हमें परिभाषित करने की आवश्यकता है 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 मेमोरी पर निर्भर करता है। यदि सेजमेकर वितरित प्रशिक्षण सक्षम है, तो कुल बैच आकार प्रत्येक डिवाइस/जीपीयू में वितरित प्रत्येक बैच का योग है। यदि हम ml.g4dn.xlarge इंस्टेंस के बजाय वितरित प्रशिक्षण के साथ ml.g16dn.4xlarge का उपयोग करते हैं, तो हमारे पास ml.g8dn.xlarge इंस्टेंस (4 GPU) की तुलना में आठ गुना (1 GPU) अधिक मेमोरी होती है। प्रति डिवाइस बैच आकार समान रहता है, लेकिन आठ डिवाइस समानांतर में प्रशिक्षण ले रहे हैं।

हमेशा की तरह सेजमेकर के साथ, हम एक बनाते हैं train.py स्क्रिप्ट मोड के साथ उपयोग करने के लिए स्क्रिप्ट और प्रशिक्षण के लिए हाइपरपैरामीटर पास करें। पेगासस के लिए निम्नलिखित कोड स्निपेट मॉडल को लोड करता है और ट्रांसफॉर्मर का उपयोग करके इसे प्रशिक्षित करता है 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.

प्रशिक्षित हगिंग फेस मॉडल को सेजमेकर में तैनात करें

हगिंग फेस के हमारे दोस्तों ने ट्रांसफॉर्मर मॉडल के लिए सेजमेकर के अनुमान को पहले से कहीं ज्यादा आसान बना दिया है सेजमेकर हगिंग फेस इंफरेंस टूलकिट. आप केवल पर्यावरण चर सेट करके पहले से प्रशिक्षित मॉडल को सीधे तैनात कर सकते हैं "HF_TASK":"summarization" (निर्देशों के लिए देखें पेगासस मॉडल), चुनना तैनाती, और फिर चुनना अमेज़न 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

जैसा कि पिछले कोड में दिखाया गया है, सेजमेकर पर हगिंगफेस के लिए इस तरह की एक अनुमान स्क्रिप्ट को केवल निम्नलिखित टेम्पलेट फ़ंक्शन की आवश्यकता होती है:

• model_fn () - प्रशिक्षण कार्य के अंत में जो सहेजा गया था उसकी सामग्री को अंदर पढ़ता है SM_MODEL_DIR, या मौजूदा मॉडल भार निर्देशिका से tar.gz फ़ाइल के रूप में सहेजा गया अमेज़न सरल भंडारण सेवा (अमेज़ॅन एस 3)। इसका उपयोग प्रशिक्षित मॉडल और संबंधित टोकननाइज़र को लोड करने के लिए किया जाता है।
• input_fn () - समापन बिंदु पर किए गए अनुरोध से प्राप्त डेटा को प्रारूपित करता है।
• predict_fn () - के आउटपुट को कॉल करता है model_fn() (मॉडल और टोकननाइज़र) के आउटपुट पर अनुमान चलाने के लिए input_fn() (स्वरूपित डेटा)।

वैकल्पिक रूप से, आप एक बना सकते हैं output_fn() के आउटपुट का उपयोग करते हुए, अनुमान स्वरूपण के लिए कार्य करता है predict_fn(), जिसे हमने इस पोस्ट में प्रदर्शित नहीं किया।

इसके बाद हम प्रशिक्षित हगिंग फेस मॉडल को सेजमेकर में संबंधित अनुमान स्क्रिप्ट के साथ तैनात कर सकते हैं हगिंग फेस सेजमेकर मॉडल वर्ग:

# 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 समीक्षाएं होती हैं। एक प्रशिक्षण सेट पर पेगासस मॉडल को फाइन-ट्यूनिंग, जिसमें पांच युगों के लिए 70% लेख शामिल थे, एक ml.p3.5xबड़े उदाहरण पर लगभग 3.16 घंटे लगे।

फिर हम मॉडल को परिनियोजित कर सकते हैं और परीक्षण सेट से कुछ उदाहरण डेटा के साथ इसका परीक्षण कर सकते हैं। स्वेटर का वर्णन करने वाली एक उदाहरण समीक्षा निम्नलिखित है:

# 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

सेजमेकर एंडपॉइंट में होस्ट की गई हमारी कस्टम इंट्रेंस स्क्रिप्ट के लिए धन्यवाद, हम विभिन्न टेक्स्ट जनरेशन मापदंडों के साथ इस समीक्षा के लिए कई सारांश तैयार कर सकते हैं। उदाहरण के लिए, हम समापन बिंदु को अलग-अलग लंबाई दंड निर्दिष्ट करते हुए बहुत कम से मध्यम लंबी सारांश की एक श्रृंखला उत्पन्न करने के लिए कह सकते हैं (लंबाई दंड जितना छोटा होगा, उत्पन्न सारांश छोटा होगा)। निम्नलिखित कुछ पैरामीटर इनपुट उदाहरण हैं, और बाद में मशीन द्वारा उत्पन्न सारांश:

# 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 से कम) का उपयोग करता है।

निष्कर्ष

आप अपने कस्टम डेटासेट पर टेक्स्ट सारांश को फाइन-ट्यून कर सकते हैं और इसे सेजमेकर पर उत्पादन के लिए इस सरल उदाहरण के साथ उपलब्ध करा सकते हैं GitHub। अतिरिक्त नमूना नोटबुक सेजमेकर पर हगिंग फेस मॉडल को प्रशिक्षित और तैनात करने के लिए भी उपलब्ध हैं।

हमेशा की तरह, AWS प्रतिक्रिया का स्वागत करता है। कृपया कोई टिप्पणी या प्रश्न सबमिट करें।

संदर्भ

[1] पेगासस: सार संक्षेप के लिए निकाले गए गैप-वाक्य के साथ पूर्व-प्रशिक्षण

लेखक के बारे में

विक्टर मालेसेविक AWS व्यावसायिक सेवाओं के साथ एक मशीन लर्निंग इंजीनियर है, जो प्राकृतिक भाषा प्रसंस्करण और MLOps के बारे में भावुक है। वह एडब्ल्यूएस पर उत्पादन के लिए चुनौतीपूर्ण गहन शिक्षण मॉडल विकसित करने और रखने के लिए ग्राहकों के साथ काम करता है। अपने खाली समय में, वह दोस्तों के साथ एक गिलास रेड वाइन और कुछ पनीर साझा करना पसंद करते हैं।

आमना नजमी एडब्ल्यूएस प्रोफेशनल सर्विसेज के साथ डेटा साइंटिस्ट हैं। वह ग्राहकों को बिग डेटा और आर्टिफिशियल इंटेलिजेंस तकनीकों के साथ व्यापार मूल्य और डेटा से अंतर्दृष्टि प्राप्त करने में मदद करने के लिए भावुक है। अपने खाली समय में, वह बागवानी और नई जगहों की यात्रा का आनंद लेती है।