Amazon SageMaker पर BLOOM-176B और OPT-30B को बड़े मॉडल इंफ़ेक्शन डीप लर्निंग कंटेनर्स और डीपस्पीड के साथ डिप्लॉय करें

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

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

इस पोस्ट में, हम दो सबसे लोकप्रिय बड़े एनएलपी मॉडलों को तैनात करने के लिए एक नए सेजमेकर बड़े मॉडल अनुमान डीएलसी का उपयोग करते हैं: बिगसाइंस ब्लूम-176बी और मेटा ऑप्ट -30 बी हगिंग फेस रिपोजिटरी से। विशेष रूप से, हम टेक्स्ट जेनरेशन उपयोग के मामले में प्रति टोकन 0.1 सेकंड विलंबता प्राप्त करने के लिए डीपस्पीड से डीप जावा लाइब्रेरी (डीजेएल) सर्विंग और टेंसर पैरेललिज़्म तकनीकों का उपयोग करते हैं।

आप हमारे संपूर्ण उदाहरण नोटबुक को हमारे . में पा सकते हैं गिटहब भंडार.

बड़े मॉडल अनुमान तकनीक

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

डीपस्पीड और एक्सीलरेट अनुमान के लिए बड़े भाषा मॉडल को अनुकूलित करने के लिए विभिन्न तकनीकों का उपयोग करते हैं। मुख्य अंतर डीपस्पीड का है अनुकूलित गुठली का उपयोग. ये कर्नेल मॉडल के गणना ग्राफ में बाधाओं को कम करके अनुमान विलंबता में नाटकीय रूप से सुधार कर सकते हैं। अनुकूलित कर्नेल विकसित करना मुश्किल हो सकता है और आमतौर पर किसी विशेष मॉडल आर्किटेक्चर के लिए विशिष्ट होता है; डीपस्पीड इन अनुकूलित कर्नेल के साथ लोकप्रिय बड़े मॉडल जैसे ऑप्ट और ब्लूम का समर्थन करता है। इसके विपरीत, हगिंग फेस की एक्सेलेरेट लाइब्रेरी में लेखन के समय अनुकूलित कर्नेल शामिल नहीं हैं। जैसा कि हम अपने परिणाम अनुभाग में चर्चा करते हैं, यह अंतर प्रदर्शन के अधिकांश किनारे के लिए जिम्मेदार है जो कि डीपस्पीड के पास त्वरण से अधिक है।

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

समाधान अवलोकन

बड़े भाषा मॉडल को प्रभावी ढंग से होस्ट करने के लिए, हमें निम्नलिखित प्रमुख क्षेत्रों में सुविधाओं और समर्थन की आवश्यकता है:

• निर्माण और परीक्षण समाधान - एमएल विकास की पुनरावृत्ति प्रकृति को देखते हुए, हमें तेजी से विफल होने की क्षमता सहित, इन मॉडलों को होस्ट किए जाने पर अनुमान समापन बिंदु कैसे व्यवहार करेगा, इसका निर्माण करने, तेजी से पुनरावृति करने और परीक्षण करने की क्षमता की आवश्यकता है। इन मॉडलों को आम तौर पर केवल p4dn या g5 जैसे बड़े उदाहरणों पर ही होस्ट किया जा सकता है, और मॉडल के आकार को देखते हुए, एक अनुमान उदाहरण को स्पिन करने और किसी भी परीक्षण पुनरावृत्ति को चलाने में कुछ समय लग सकता है। स्थानीय परीक्षण में आमतौर पर बाधाएं होती हैं क्योंकि आपको परीक्षण के लिए आकार में एक समान उदाहरण की आवश्यकता होती है, और इन मॉडलों को प्राप्त करना आसान नहीं होता है।
• पैमाने पर तैनाती और चल रहा है - मॉडल फ़ाइलों को अनुमान के उदाहरणों पर लोड करने की आवश्यकता होती है, जो आकार को देखते हुए अपने आप में एक चुनौती प्रस्तुत करता है। ब्लूम-176बी के उदाहरण के रूप में टार / अन-टार को बनाने में लगभग 1 घंटा और लोड होने में एक और घंटा लगता है। मॉडल फ़ाइलों तक आसान पहुंच की अनुमति देने के लिए हमें एक वैकल्पिक तंत्र की आवश्यकता है।
• मॉडल को सिंगलटन के रूप में लोड किया जा रहा है - एक बहु-कार्यकर्ता प्रक्रिया के लिए, हमें यह सुनिश्चित करने की आवश्यकता है कि मॉडल केवल एक बार लोड हो ताकि हम दौड़ की स्थिति में न आएं और अनावश्यक संसाधनों को खर्च न करें। इस पोस्ट में, हम सीधे से लोड करने का एक तरीका दिखाते हैं अमेज़न सरल भंडारण सेवा (अमेज़ॅन एस 3)। हालाँकि, यह केवल तभी काम करता है जब हम डीजेएल की डिफ़ॉल्ट सेटिंग्स का उपयोग करते हैं। इसके अलावा, एंडपॉइंट्स के किसी भी स्केलिंग को कुछ मिनटों में स्पिन करने में सक्षम होना चाहिए, जो इस बात पर पुनर्विचार करने के लिए कहता है कि मॉडल कैसे लोड और वितरित किए जा सकते हैं।
• ढांचे को साझा करना - इन मॉडलों को आमतौर पर एक टेंसर पैरेललिज्म मैकेनिज्म या पाइपलाइन शार्डिंग द्वारा विशिष्ट शार्डिंग तकनीकों के रूप में होना चाहिए, और हमारे पास टेन्सर शार्डिंग के शीर्ष पर निर्मित ज़ीरो शार्डिंग जैसी उन्नत अवधारणाएं हैं। शार्डिंग तकनीकों के बारे में अधिक जानकारी के लिए देखें मॉडल समानता. इसे प्राप्त करने के लिए, हमारे पास विभिन्न संयोजन हो सकते हैं और NIVIDIA, डीपस्पीड और अन्य से चौखटे का उपयोग कर सकते हैं। इसके लिए BYOC का परीक्षण करने या 1P कंटेनरों का उपयोग करने और समाधानों पर पुनरावृति करने और बेंचमार्किंग परीक्षण चलाने की क्षमता की आवश्यकता है। आप अतुल्यकालिक, सर्वर रहित और अन्य जैसे विभिन्न होस्टिंग विकल्पों का परीक्षण करना चाह सकते हैं।
• हार्डवेयर चयन - हार्डवेयर में आपकी पसंद उपरोक्त सभी बिंदुओं और आगे के ट्रैफ़िक पैटर्न, उपयोग के मामले की ज़रूरतों और मॉडल आकारों द्वारा निर्धारित की जाती है।

इस पोस्ट में, हम SageMaker पर BLOOM-176B और OPT-30B को होस्ट करने के लिए डीपस्पीड की अनुकूलित कर्नेल और टेंसर पैरेललिज़्म तकनीकों का उपयोग करते हैं। हम अनुकूलित कर्नेल और टेंसर समानता के प्रदर्शन लाभों को प्रदर्शित करने के लिए एक्सेलेरेट के परिणामों की तुलना भी करते हैं। डीपस्पीड और एक्सीलरेट के बारे में अधिक जानकारी के लिए देखें डीपस्पीड इंफ़ेक्शन: अभूतपूर्व पैमाने पर ट्रांसफार्मर मॉडल के कुशल अनुमान को सक्षम करना और डीपस्पीड और एक्सीलरेट के साथ अविश्वसनीय रूप से तेज़ ब्लूम अनुमान.

हम इस उदाहरण में मॉडल सर्विंग समाधान के रूप में DJLServing का उपयोग करते हैं। DJLServing डीप जावा लाइब्रेरी (DJL) द्वारा संचालित एक उच्च-प्रदर्शन सार्वभौमिक मॉडल सर्विंग समाधान है जो प्रोग्रामिंग भाषा अज्ञेयवादी है। डीजेएल और डीजेएल सर्विंग के बारे में अधिक जानने के लिए, देखें DJLServing और DeepSpeed ​​मॉडल के समानांतर अनुमान का उपयोग करके Amazon SageMaker पर बड़े मॉडल परिनियोजित करें.

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

निम्न चरण प्रदर्शित करते हैं कि DJLServing और एक SageMaker बड़े मॉडल अनुमान कंटेनर का उपयोग करके SageMaker में BLOOM-176B मॉडल को कैसे परिनियोजित किया जाए। पूरा उदाहरण हमारे . में भी उपलब्ध है गिटहब भंडार.

डीजेएलसर्विंग सेजमेकर डीएलसी इमेज का उपयोग करना

जिस क्षेत्र में आप नोटबुक चला रहे हैं, उस क्षेत्र को अपने विशिष्ट क्षेत्र से बदलने के बाद DJLServing SageMaker DLC छवि का उपयोग करने के लिए निम्नलिखित कोड का उपयोग करें:

763104351884.dkr.ecr..amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113
# example uri might be like 763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113

हमारी मॉडल फ़ाइल बनाएं

सबसे पहले, हम एक फाइल बनाते हैं जिसका नाम है serving.properties जिसमें कोड की केवल एक पंक्ति होती है। यह डीजेएल मॉडल सर्वर को डीपस्पीड इंजन का उपयोग करने के लिए कहता है। फ़ाइल में निम्न कोड है:

engine=DeepSpeed

serving.properties DJLServing द्वारा परिभाषित एक फ़ाइल है जिसका उपयोग प्रति-मॉडल कॉन्फ़िगरेशन को कॉन्फ़िगर करने के लिए किया जाता है।

अगला, हम अपना बनाते हैं model.py फ़ाइल, जो लोड करने के लिए आवश्यक कोड को परिभाषित करती है और फिर मॉडल की सेवा करती है। हमारे कोड में, हम में पढ़ते हैं TENSOR_PARALLEL_DEGREE पर्यावरण चर (डिफ़ॉल्ट मान 1 है)। यह उन उपकरणों की संख्या निर्धारित करता है जिन पर टेंसर समानांतर मॉड्यूल वितरित किए जाते हैं। ध्यान दें कि डीपस्पीड कुछ अंतर्निहित विभाजन परिभाषाएँ प्रदान करता है, जिसमें ब्लूम मॉडल के लिए एक भी शामिल है। हम इसे निर्दिष्ट करके उपयोग करते हैं replace_method और relpace_with_kernel_inject. यदि आपके पास एक अनुकूलित मॉडल है और प्रभावी ढंग से विभाजन के लिए डीपस्पीड की आवश्यकता है, तो आपको बदलने की जरूरत है relpace_with_kernel_inject सेवा मेरे false और जोड़ injection_policy रनटाइम विभाजन को काम करने के लिए। अधिक जानकारी के लिए देखें अनुमान के लिए प्रारंभ करना. हमारे उदाहरण के लिए, हमने डीपस्पीड पर पूर्व-विभाजित ब्लूम मॉडल का उपयोग किया।

दूसरे, में model.py फ़ाइल में, हम मॉडल को ऐमज़ॉन S3 से भी लोड करते हैं जब समापन बिंदु काता गया है। मॉडल में लोड किया गया है /tmp कंटेनर पर जगह क्योंकि सेजमेकर मैप करता है /tmp को अमेज़न इलास्टिक ब्लॉक स्टोर (अमेज़ॅन ईबीएस) वॉल्यूम जो तब माउंट किया जाता है जब हम समापन बिंदु निर्माण पैरामीटर निर्दिष्ट करते हैं VolumeSizeInGB. p4dn जैसे उदाहरणों के लिए, जो वॉल्यूम इंस्टेंस के साथ पूर्व-निर्मित आते हैं, हम इसका लाभ उठाना जारी रख सकते हैं /tmp कंटेनर पर। निम्नलिखित कोड देखें:

from djl_python import Input, Output
import os
import deepspeed
import torch
import torch.distributed as dist
import sys
import subprocess
import time
from glob import glob
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from transformers.models.opt.modeling_opt import OPTDecoderLayer

predictor = None

def check_config():
    local_rank = os.getenv('LOCAL_RANK')
    
    if not local_rank:
        return False
    return True
    
def get_model():

    if not check_config():
        raise Exception("DJL:DeepSpeed configurations are not default. This code does not support non default configurations") 
    
    tensor_parallel = int(os.getenv('TENSOR_PARALLEL_DEGREE', '1'))
    local_rank = int(os.getenv('LOCAL_RANK', '0'))
    model_dir = "/tmp/model"
    bucket = os.environ.get("MODEL_S3_BUCKET")
    key_prefix = os.environ.get("MODEL_S3_PREFIX")
    print(f"rank: {local_rank}")
    if local_rank == 0:
        if f"{model_dir}/DONE" not in glob(f"{model_dir}/*"):
            print("Starting Model downloading files")
            try:
                proc_run = subprocess.run(
                    ["aws", "s3", "cp", "--recursive", f"s3://{bucket}/{key_prefix}", model_dir]
                )
                print("Model downloading finished")
                # write file when download complete. Could use dist.barrier() but this makes it easier to check if model is downloaded in case of retry
                with open(f"{model_dir}/DONE", "w") as f:
                    f.write("download_complete")
                    
                proc_run.check_returncode() # to throw the error in case there was one
                
            except subprocess.CalledProcessError as e:
                print ( "Model download failed: Error:nreturn code: ", e.returncode, "nOutput: ", e.stderr )
                raise # FAIL FAST  
                               
    dist.barrier()
                
    
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    
    # has to be FP16 as Int8 model loading not yet supported
    with deepspeed.OnDevice(dtype=torch.float16, device="meta"):
        model = AutoModelForCausalLM.from_config(
            AutoConfig.from_pretrained(model_dir), torch_dtype=torch.bfloat16
        )
    model = model.eval()
    
    model = deepspeed.init_inference(
        model,
        mp_size=tensor_parallel,
        dtype=torch.int8,
        base_dir = model_dir,
        checkpoint=os.path.join(model_dir, "ds_inference_config.json"),
        replace_method='auto',
        replace_with_kernel_inject=True
    )

    model = model.module
    dist.barrier()
    return model, tokenizer

DJLServing में परिभाषित किसी भी पाइप पैकेज पर रनटाइम इंस्टॉलेशन का प्रबंधन करता है requirement.txt. इस फ़ाइल में होगा:

awscli
boto3

हमने एक निर्देशिका बनाई है जिसका नाम है code और model.py, serving.properties, तथा requirements.txt फ़ाइलें पहले से ही इस निर्देशिका में बनाई गई हैं। फ़ाइलों को देखने के लिए, आप टर्मिनल से निम्न कोड चला सकते हैं:

mkdir -p code
cat code/model.py 
cat code/serving.properties 
cat code/requirements.txt 

निम्नलिखित आंकड़ा की संरचना को दर्शाता है model.tar.gz.

अंत में, हम मॉडल फ़ाइल बनाते हैं और उसे Amazon S3 पर अपलोड करते हैं:

tar cvfz model.tar.gz code
s3_code_artifact = sess.upload_data("model.tar.gz", bucket, s3_code_prefix)

हगिंग फेस (वैकल्पिक) से मॉडल को डाउनलोड और स्टोर करें

यदि आप मॉडल को Amazon S3 में डाउनलोड करना चाहते हैं और वहां से इसका उपयोग करना चाहते हैं, तो हमने इस खंड में चरण प्रदान किए हैं। चरण GitHub पर Jupyter फ़ाइल में दिए गए हैं। निम्न स्क्रीनशॉट चरणों का एक स्नैपशॉट दिखाता है।

एक सेजमेकर मॉडल बनाएं

अब हम a . बनाते हैं सेजमेकर मॉडल। हम उपयोग करते हैं अमेज़ॅन इलास्टिक कंटेनर रजिस्ट्री (अमेज़ॅन ईसीआर) सेजमेकर मॉडल बनाने के लिए पिछले चरण से मॉडल आर्टिफैक्ट द्वारा प्रदान की गई छवि। मॉडल सेटअप में, हम कॉन्फ़िगर करते हैं TENSOR_PARALLEL_DEGREE=8, जिसका अर्थ है कि मॉडल को 8 GPU के साथ विभाजित किया गया है। निम्नलिखित कोड देखें:

PrimaryContainer={
        "Image": inference_image_uri,
        "ModelDataUrl": s3_code_artifact,
        "Environment": {
            "MODEL_S3_BUCKET": bucket,
            "MODEL_S3_PREFIX": s3_model_prefix,
            "TENSOR_PARALLEL_DEGREE": "8",
},

जुपिटर फ़ाइल में पिछले सेल को चलाने के बाद, आप निम्न के जैसा आउटपुट देखते हैं:

{
    "ModelArn": "arn:aws:sagemaker:us-east-1::model/bloom-djl-ds-"
}

एक सेजमेकर एंडपॉइंट बनाएं

आप परीक्षण के लिए कई GPU के साथ किसी भी उदाहरण का उपयोग कर सकते हैं। इस डेमो में, हम p4d.24xlarge इंस्टेंस का उपयोग करते हैं। निम्नलिखित कोड में, ध्यान दें कि हम कैसे सेट करते हैं ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSeconds, तथा VolumeSizeInGB बड़े मॉडल आकार को समायोजित करने के लिए पैरामीटर। VolumeSizeInGB पैरामीटर ईबीएस वॉल्यूम अटैचमेंट का समर्थन करने वाले जीपीयू इंस्टेंस पर लागू होता है।

endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.p4d.24xlarge",
            "InitialInstanceCount": 1,
            #"VolumeSizeInGB" : 200,
            "ModelDataDownloadTimeoutInSeconds": 2400,
            "ContainerStartupHealthCheckTimeoutInSeconds": 2400,
        },
    ],
)'

अंत में, हम एक सेजमेकर एंडपॉइंट बनाते हैं:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

आप इसे निम्नलिखित कोड में प्रिंट आउट देखते हैं:

{
    "EndpointArn": "arn:aws:sagemaker:us-east-1::endpoint/bloom-djl-ds-"
}

समापन बिंदु शुरू करने में कुछ समय लग सकता है। यदि आप इसमें भाग लेते हैं तो आप कुछ और बार कोशिश कर सकते हैं InsufficientInstanceCapacity त्रुटि, या आप अपने खाते में सीमा बढ़ाने के लिए AWS से अनुरोध कर सकते हैं।

प्रदर्शन सुधारना

यदि आप एक अलग मॉडल के साथ इस पोस्ट और साथ में नोटबुक का उपयोग करने का इरादा रखते हैं, तो आप सेजमेकर, डीपस्पीड और डीजेएल द्वारा पेश किए जाने वाले कुछ ट्यून करने योग्य मापदंडों का पता लगाना चाह सकते हैं। इन मापदंडों के साथ बार-बार प्रयोग करने से आपके होस्ट किए गए बड़े मॉडल की विलंबता, थ्रूपुट और लागत पर महत्वपूर्ण प्रभाव पड़ सकता है। ट्यूनिंग मापदंडों के बारे में अधिक जानने के लिए, जैसे कि श्रमिकों की संख्या, टेंसर समानांतरता की डिग्री, नौकरी की कतार का आकार, और अन्य, देखें डीजेएल सेवित विन्यास और DJLServing और DeepSpeed ​​मॉडल के समानांतर अनुमान का उपयोग करके Amazon SageMaker पर बड़े मॉडल परिनियोजित करें.

परिणाम

इस पोस्ट में, हमने सेजमेकर एमएल इंस्टेंस पर ब्लूम-176बी और ऑप्ट-30बी को होस्ट करने के लिए डीपस्पीड का इस्तेमाल किया। निम्नलिखित तालिका हमारे प्रदर्शन परिणामों को सारांशित करती है, जिसमें हगिंग फेस एक्सीलरेट के साथ तुलना भी शामिल है। विलंबता एक 256-टोकन स्ट्रिंग को चार बार उत्पन्न करने में लगने वाले मिलीसेकंड की संख्या को दर्शाती है (batch_size=4) मॉडल से। थ्रूपुट प्रत्येक परीक्षण के लिए प्रति सेकंड उत्पादित टोकन की संख्या को दर्शाता है। हगिंग फेस एक्सीलरेट के लिए, हमने GPU मेमोरी मैपिंग के साथ लाइब्रेरी की डिफ़ॉल्ट लोडिंग का उपयोग किया। डीपस्पीड के लिए, हमने इसके तेज चेकपॉइंट लोडिंग तंत्र का उपयोग किया।

विलंबता के दृष्टिकोण से, डीपस्पीड ब्लूम-3.4बी के लिए लगभग 176 गुना तेज है और एक्सीलरेट की तुलना में ऑप्ट-5.6बी के लिए 30 गुना तेज है। डीपस्पीड की अनुकूलित गुठली विलंबता में इस अंतर के लिए जिम्मेदार है। इन परिणामों को देखते हुए, यदि आपकी पसंद का मॉडल समर्थित है, तो हम आपको डीपस्पीड ओवर एक्सीलरेट का उपयोग करने की सलाह देते हैं।

यह भी ध्यान देने योग्य है कि डीपस्पीड के साथ मॉडल लोडिंग समय बहुत कम था, अगर आप अपने समापन बिंदुओं की संख्या को जल्दी से बढ़ाने की आवश्यकता का अनुमान लगाते हैं तो यह एक बेहतर विकल्प है। यदि आपके पास ऐसे मॉडल या मॉडल सटीक हैं जो डीपस्पीड द्वारा समर्थित नहीं हैं, तो एक्सेलेरेट की अधिक लचीली पाइपलाइन समानांतर तकनीक एक बेहतर विकल्प हो सकती है।

ये परिणाम विभिन्न मॉडल आकारों के विलंबता और थ्रूपुट में अंतर भी प्रदर्शित करते हैं। हमारे परीक्षणों में, OPT-30B एक आवृत्ति प्रकार पर BLOOM-2.4B की तुलना में प्रति यूनिट समय में 176 गुना टोकन उत्पन्न करता है जो तीन गुना से अधिक सस्ता है। कीमत प्रति यूनिट थ्रूपुट के आधार पर, G30xl इंस्टेंस पर OPT-5.24B, p8.9d.176xl इंस्टेंस पर BLOOM-4B से 24 गुना बेहतर है। यदि आपके पास सख्त विलंबता, थ्रूपुट या लागत सीमाएं हैं, तो संभव सबसे छोटे मॉडल का उपयोग करने पर विचार करें जो अभी भी कार्यात्मक आवश्यकताओं को प्राप्त करेगा।

क्लीन अप

सर्वोत्तम प्रथाओं के भाग के रूप में हमेशा निष्क्रिय उदाहरणों को हटाने की अनुशंसा की जाती है। नीचे दिया गया कोड आपको दिखाता है कि उदाहरणों को कैसे हटाया जाए।

# - Delete the end point
sm_client.delete_endpoint(EndpointName=endpoint_name)

# - In case the end point failed we still want to delete the model
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)

वैकल्पिक रूप से अपने S3 . से मॉडल चेक प्वाइंट को हटा दें

!aws s3 rm --recursive s3:///{s3_model_prefix}

निष्कर्ष

इस पोस्ट में, हमने दिखाया कि कैसे दो बड़े भाषा मॉडल, BLOOM-176B और OPT-30B को होस्ट करने के लिए SageMaker बड़े मॉडल अनुमान कंटेनरों का उपयोग किया जाए। हमने सिंगल सेजमेकर एमएल इंस्टेंस पर कई जीपीयू के साथ डीपस्पीड के मॉडल समानांतर तकनीकों का इस्तेमाल किया।

अमेज़ॅन सेजमेकर और इसकी बड़ी मॉडल अनुमान क्षमताओं के बारे में अधिक जानकारी के लिए, देखें अमेज़ॅन सेजमेकर अब विन्यास योग्य वॉल्यूम आकार और टाइमआउट कोटा के माध्यम से बड़े मॉडल को तैनात करने का समर्थन करता है और वास्तविक समय अनुमान.

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

साइमन ज़मरीन एक एआई / एमएल सॉल्यूशन आर्किटेक्ट है जिसका मुख्य फोकस ग्राहकों को उनकी डेटा परिसंपत्तियों से मूल्य निकालने में मदद कर रहा है। अपने खाली समय में, साइमन परिवार के साथ समय बिताना, विज्ञान-फाई पढ़ना और विभिन्न DIY घर परियोजनाओं पर काम करना पसंद करता है।

रूपिंदर ग्रेवाल एडब्ल्यूएस के साथ सीनियर एआई/एमएल स्पेशलिस्ट सॉल्यूशंस आर्किटेक्ट हैं। वह वर्तमान में सेजमेकर पर मॉडल और एमएलओ की सेवा पर ध्यान केंद्रित करता है। इस भूमिका से पहले उन्होंने मशीन लर्निंग इंजीनियर बिल्डिंग और होस्टिंग मॉडल के रूप में काम किया है। काम के अलावा उन्हें टेनिस खेलना और पहाड़ की पगडंडियों पर बाइक चलाना पसंद है।

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

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

धवल पटेल AWS में प्रिंसिपल मशीन लर्निंग आर्किटेक्ट हैं। उन्होंने वितरित कंप्यूटिंग और आर्टिफिशियल इंटेलिजेंस से संबंधित समस्याओं पर बड़े उद्यमों से लेकर मध्यम आकार के स्टार्टअप तक के संगठनों के साथ काम किया है। वह एनएलपी और कंप्यूटर विज़न डोमेन सहित डीप लर्निंग पर ध्यान केंद्रित करता है। वह ग्राहकों को सेजमेकर पर उच्च प्रदर्शन मॉडल अनुमान प्राप्त करने में मदद करता है।

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

किंगवेई ली अमेज़न वेब सर्विसेज में मशीन लर्निंग स्पेशलिस्ट है। उन्होंने अपनी पीएच.डी. ऑपरेशन रिसर्च में जब उन्होंने अपने सलाहकार के अनुसंधान अनुदान खाते को तोड़ा और नोबेल पुरस्कार देने में असफल रहे, तो उन्होंने वादा किया था। वर्तमान में वह वित्तीय सेवा और बीमा उद्योग में ग्राहकों को AWS पर मशीन लर्निंग समाधान बनाने में मदद करता है। अपने खाली समय में, वह पढ़ना और पढ़ाना पसंद करते हैं।

रॉबर्ट वैन ड्यूसेना अमेज़ॅन सेजमेकर के साथ एक वरिष्ठ उत्पाद प्रबंधक हैं। वह बड़े मॉडल अनुमान जैसे अनुप्रयोगों के लिए गहन शिक्षण मॉडल अनुकूलन का नेतृत्व करता है।

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