लागत-कुशल, उच्च-प्रदर्शन AI अनुमान के लिए Amazon EC2 DL2q उदाहरण अब आम तौर पर उपलब्ध है | अमेज़न वेब सेवाएँ

यह क्वालकॉम एआई से एके रॉय द्वारा एक अतिथि पोस्ट है।

अमेज़न इलास्टिक कम्प्यूट क्लाउड (Amazon EC2) क्वालकॉम एआई 2 मानक त्वरक द्वारा संचालित DL100q इंस्टेंसेस का उपयोग क्लाउड में डीप लर्निंग (डीएल) वर्कलोड को लागत-कुशलतापूर्वक तैनात करने के लिए किया जा सकता है। उनका उपयोग डीएल वर्कलोड के प्रदर्शन और सटीकता को विकसित करने और मान्य करने के लिए भी किया जा सकता है जिसे क्वालकॉम उपकरणों पर तैनात किया जाएगा। DL2q इंस्टेंसेस क्वालकॉम की कृत्रिम बुद्धिमान (एआई) तकनीक को क्लाउड पर लाने वाले पहले उदाहरण हैं।

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

नए DL2q उदाहरण पर प्रकाश डाला गया

प्रत्येक DL2q उदाहरण में आठ क्वालकॉम क्लाउड AI100 एक्सेलेरेटर शामिल हैं, जिसमें Int2.8 अनुमान प्रदर्शन के 8 PetaOps और FP1.4 अनुमान प्रदर्शन के 16 PetaFlops का समग्र प्रदर्शन है। उदाहरण में कुल 112 एआई कोर, 128 जीबी की एक्सीलरेटर मेमोरी क्षमता और 1.1 टीबी प्रति सेकंड की मेमोरी बैंडविड्थ है।

प्रत्येक DL2q इंस्टेंस में 96 vCPU, 768 GB की सिस्टम मेमोरी क्षमता और 100 Gbps की नेटवर्किंग बैंडविड्थ का समर्थन करता है। अमेज़ॅन इलास्टिक ब्लॉक स्टोर (अमेज़ॅन ईबीएस) 19 जीबीपीएस का स्टोरेज।

क्वालकॉम क्लाउड AI100 त्वरक नवाचार

क्लाउड AI100 एक्सेलेरेटर सिस्टम-ऑन-चिप (SoC) एक उद्देश्य-निर्मित, स्केलेबल मल्टी-कोर आर्किटेक्चर है, जो डेटासेंटर से किनारे तक फैले गहन-शिक्षण उपयोग-मामलों की एक विस्तृत श्रृंखला का समर्थन करता है। एसओसी 126 एमबी की उद्योग-अग्रणी ऑन-डाई एसआरएएम क्षमता के साथ स्केलर, वेक्टर और टेंसर कंप्यूट कोर को नियोजित करता है। कोर एक उच्च-बैंडविड्थ कम-विलंबता नेटवर्क-ऑन-चिप (NoC) जाल से जुड़े हुए हैं।

AI100 एक्सेलेरेटर मॉडलों और उपयोग-मामलों की एक विस्तृत और विस्तृत श्रृंखला का समर्थन करता है। नीचे दी गई तालिका मॉडल समर्थन की सीमा पर प्रकाश डालती है।

* अधिकांश ऑटोमोटिव नेटवर्क मिश्रित नेटवर्क होते हैं जिनमें व्यक्तिगत नेटवर्क का मिश्रण होता है।

DL2q एक्सेलेरेटर पर बड़ा ऑन-डाई SRAM उन्नत प्रदर्शन तकनीकों जैसे वजन को संग्रहीत करने के लिए MX6 माइक्रो-एक्सपोनेंट परिशुद्धता और एक्सेलेरेटर-टू-एक्सीरेटर संचार के लिए MX9 माइक्रो-एक्सपोनेंट परिशुद्धता के कुशल कार्यान्वयन को सक्षम बनाता है। माइक्रो-एक्सपोनेंट तकनीक का वर्णन निम्नलिखित ओपन कंप्यूट प्रोजेक्ट (ओसीपी) उद्योग घोषणा में किया गया है: एएमडी, आर्म, इंटेल, मेटा, माइक्रोसॉफ्ट, एनवीआईडीआईए और क्वालकॉम एआई के लिए अगली पीढ़ी के संकीर्ण परिशुद्धता डेटा प्रारूपों को मानकीकृत करते हैं » ओपन कंप्यूट प्रोजेक्ट.

उदाहरण उपयोगकर्ता प्रदर्शन-प्रति-लागत को अधिकतम करने के लिए निम्नलिखित रणनीति का उपयोग कर सकता है:

• ऑन-एक्सीलेटर डीडीआर मेमोरी में एमएक्स6 माइक्रो-एक्सपोनेंट परिशुद्धता का उपयोग करके वजन स्टोर करें। एमएक्स6 परिशुद्धता का उपयोग उपलब्ध मेमोरी क्षमता और मेमोरी-बैंडविड्थ के उपयोग को अधिकतम करता है ताकि श्रेणी में सर्वोत्तम थ्रूपुट और विलंबता प्रदान की जा सके।
• उच्च-प्रदर्शन कम-विलंबता MX16 से FP6 कर्नेल को लागू करने के लिए, कार्ड पर बेहतर ऑन-चिप SRAM और अतिरिक्त TOPs का उपयोग करते हुए, आवश्यक उपयोग केस सटीकता प्रदान करने के लिए FP16 में गणना करें।
• वजन के पुन: उपयोग को अधिकतम करने के लिए उपलब्ध बड़े ऑन-चिप एसआरएएम का उपयोग करके एक अनुकूलित बैचिंग रणनीति और उच्च बैच-आकार का उपयोग करें, जबकि ऑन-चिप सक्रियण को अधिकतम संभव तक बनाए रखें।

DL2q AI स्टैक और टूलचेन

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

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

किसी मॉडल के प्रदर्शन को ट्यून करने के बारे में अधिक जानने के लिए, देखें क्लाउड एआई 100 प्रमुख प्रदर्शन पैरामीटर प्रलेखन।

DL2q इंस्टेंसेस के साथ आरंभ करें

इस उदाहरण में, आप पूर्व-प्रशिक्षित को संकलित और तैनात करते हैं बर्ट मॉडल से गले लगना चार चरणों में, पूर्व-निर्मित उपलब्ध DL2q AMI का उपयोग करके EC2 DL2q इंस्टेंस पर।

आप या तो पूर्व-निर्मित का उपयोग कर सकते हैं क्वालकॉम DLAMI उदाहरण के लिए या Amazon Linux2 AMI से शुरू करें और इसमें उपलब्ध क्लाउड AI 2 प्लेटफ़ॉर्म और ऐप्स SDK के साथ अपना स्वयं का DL100q AMI बनाएं अमेज़न सरल भंडारण सेवा (अमेज़न S3) बाल्टी: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

अनुसरण किए जाने वाले चरण पूर्व-निर्मित DL2q AMI का उपयोग करते हैं, क्वालकॉम बेस AL2 DLAMI.

क्वालकॉम बेस AL2 DLAMI AMI के साथ अपने DL2q इंस्टेंस तक पहुंचने के लिए SSH का उपयोग करें और चरण 1 से 4 तक का पालन करें।

चरण 1. पर्यावरण स्थापित करें और आवश्यक पैकेज स्थापित करें

1. पायथन 3.8 स्थापित करें।

   sudo amazon-linux-extras install python3.8

2. पायथन 3.8 वर्चुअल वातावरण सेट करें।

   python3.8 -m venv /home/ec2-user/userA/pyenv

3. पायथन 3.8 वर्चुअल वातावरण सक्रिय करें।

   source /home/ec2-user/userA/pyenv/bin/activate

4. में दिखाए गए आवश्यक पैकेज स्थापित करें आवश्यकताएँ.txt दस्तावेज़ क्वालकॉम सार्वजनिक जीथब साइट पर उपलब्ध है।

   pip3 install -r requirements.txt

5. आवश्यक पुस्तकालयों को आयात करें।

   import transformers 
   from transformers import AutoTokenizer, AutoModelForMaskedLM
   import sys
   import qaic
   import os
   import torch
   import onnx
   from onnxsim import simplify
   import argparse
   import numpy as np

चरण 2. मॉडल आयात करें

1. मॉडल को आयात और टोकनाइज़ करें।

   model_card = 'bert-base-cased'
   model = AutoModelForMaskedLM.from_pretrained(model_card)
   tokenizer = AutoTokenizer.from_pretrained(model_card)

2. एक नमूना इनपुट परिभाषित करें और निकालें inputIds और attentionMask.

   sentence = "The dog [MASK] on the mat."
   encodings = tokenizer(sentence, max_length=128, truncation=True, padding="max_length", return_tensors='pt')
   inputIds = encodings["input_ids"]
   attentionMask = encodings["attention_mask"]

3. मॉडल को ONNX में कनवर्ट करें, जिसे बाद में कंपाइलर को पास किया जा सकता है।

   # Set dynamic dims and axes.
   dynamic_dims = {0: 'batch', 1 : 'sequence'}
   dynamic_axes = {
       "input_ids" : dynamic_dims,
       "attention_mask" : dynamic_dims,
       "logits" : dynamic_dims
   }
   input_names = ["input_ids", "attention_mask"]
   inputList = [inputIds, attentionMask]
   
   torch.onnx.export(
       model,
       args=tuple(inputList),
       f=f"{gen_models_path}/{model_base_name}.onnx",
       verbose=False,
       input_names=input_names,
       output_names=["logits"],
       dynamic_axes=dynamic_axes,
       opset_version=11,
   )

4. आप मॉडल को FP16 परिशुद्धता में चलाएंगे। इसलिए, आपको यह जांचने की ज़रूरत है कि क्या मॉडल में FP16 रेंज से परे कोई स्थिरांक है। मॉडल को पास करें fix_onnx_fp16 आवश्यक सुधारों के साथ नई ONNX फ़ाइल उत्पन्न करने के लिए फ़ंक्शन।

   from onnx import numpy_helper
           
   def fix_onnx_fp16(
       gen_models_path: str,
       model_base_name: str,
   ) -> str:
       finfo = np.finfo(np.float16)
       fp16_max = finfo.max
       fp16_min = finfo.min
       model = onnx.load(f"{gen_models_path}/{model_base_name}.onnx")
       fp16_fix = False
       for tensor in onnx.external_data_helper._get_all_tensors(model):
           nptensor = numpy_helper.to_array(tensor, gen_models_path)
           if nptensor.dtype == np.float32 and (
               np.any(nptensor > fp16_max) or np.any(nptensor < fp16_min)
           ):
               # print(f'tensor value : {nptensor} above {fp16_max} or below {fp16_min}')
               nptensor = np.clip(nptensor, fp16_min, fp16_max)
               new_tensor = numpy_helper.from_array(nptensor, tensor.name)
               tensor.CopyFrom(new_tensor)
               fp16_fix = True
               
       if fp16_fix:
           # Save FP16 model
           print("Found constants out of FP16 range, clipped to FP16 range")
           model_base_name += "_fix_outofrange_fp16"
           onnx.save(model, f=f"{gen_models_path}/{model_base_name}.onnx")
           print(f"Saving modified onnx file at {gen_models_path}/{model_base_name}.onnx")
       return model_base_name
   
   fp16_model_name = fix_onnx_fp16(gen_models_path=gen_models_path, model_base_name=model_base_name)

चरण 3. मॉडल संकलित करें

RSI qaic-exec मॉडल को संकलित करने के लिए कमांड लाइन इंटरफ़ेस (सीएलआई) कंपाइलर टूल का उपयोग किया जाता है। इस कंपाइलर का इनपुट चरण 2 में उत्पन्न ONNX फ़ाइल है। कंपाइलर एक बाइनरी फ़ाइल बनाता है (जिसे कहा जाता है) क्यूपीसीके लिए, क्वालकॉम प्रोग्राम कंटेनर) द्वारा परिभाषित पथ में -aic-binary-dir तर्क।

नीचे दिए गए कंपाइल कमांड में, आप मॉडल को कंपाइल करने के लिए चार एआई कंप्यूट कोर और एक के बैच आकार का उपयोग करते हैं।

/opt/qti-aic/exec/qaic-exec 
-m=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16.onnx 
-aic-num-cores=4 
-convert-to-fp16 
-onnx-define-symbol=batch,1 -onnx-define-symbol=sequence,128 
-aic-binary-dir=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc 
-aic-hw -aic-hw-version=2.0 
-compile-only

QPC में उत्पन्न होता है bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc फ़ोल्डर.

चरण 4. मॉडल चलाएँ

DL100q उदाहरण में क्लाउड AI2 क्वालकॉम एक्सेलेरेटर पर अनुमान चलाने के लिए एक सत्र सेट करें।

क्वालकॉम qaic पायथन लाइब्रेरी एपीआई का एक सेट है जो क्लाउड AI100 एक्सेलेरेटर पर अनुमान चलाने के लिए समर्थन प्रदान करता है।

1. सत्र का उदाहरण बनाने के लिए सत्र एपीआई कॉल का उपयोग करें। सेशन एपीआई कॉल क्यूएआईसी पायथन लाइब्रेरी का उपयोग करने का प्रवेश बिंदु है।

   qpcPath = 'bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc'
   
   bert_sess = qaic.Session(model_path= qpcPath+'/programqpc.bin', num_activations=1)  
   bert_sess.setup() # Loads the network to the device. 
   
   # Here we are reading out all the input and output shapes/types
   input_shape, input_type = bert_sess.model_input_shape_dict['input_ids']
   attn_shape, attn_type = bert_sess.model_input_shape_dict['attention_mask']
   output_shape, output_type = bert_sess.model_output_shape_dict['logits']
   
   #create the input dictionary for given input sentence
   input_dict = {"input_ids": inputIds.numpy().astype(input_type), "attention_mask" : attentionMask.numpy().astype(attn_type)}
   
   #run inference on Cloud AI 100
   output = bert_sess.run(input_dict)

2. आउटपुट बफ़र से डेटा को पुनर्गठित करें output_shape और output_type.

   token_logits = np.frombuffer(output['logits'], dtype=output_type).reshape(output_shape)

3. उत्पादित आउटपुट को डीकोड करें।

   mask_token_logits = torch.from_numpy(token_logits[0, mask_token_index, :]).unsqueeze(0)
   top_5_results = torch.topk(mask_token_logits, 5, dim=1)
   print("Model output (top5) from Qualcomm Cloud AI 100:")
   for i in range(5):
       idx = top_5_results.indices[0].tolist()[i]
       val = top_5_results.values[0].tolist()[i]
       word = tokenizer.decode([idx])
       print(f"{i+1} :(word={word}, index={idx}, logit={round(val,2)})")

यहां इनपुट वाक्य "चटाई पर कुत्ता [MASK]" के लिए आउटपुट दिए गए हैं।

1 :(word=sat, index=2068, logit=11.46)
2 :(word=landed, index=4860, logit=11.11)
3 :(word=spat, index=15732, logit=10.95)
4 :(word=settled, index=3035, logit=10.84)
5 :(word=was, index=1108, logit=10.75)

इतना ही। बस कुछ ही चरणों के साथ, आपने Amazon EC2 DL2q इंस्टेंस पर एक PyTorch मॉडल संकलित और चलाया। DL2q इंस्टेंस पर ऑनबोर्डिंग और मॉडल संकलित करने के बारे में अधिक जानने के लिए, देखें क्लाउड AI100 ट्यूटोरियल दस्तावेज़ीकरण।

इस बारे में अधिक जानने के लिए कि कौन सा DL मॉडल आर्किटेक्चर AWS DL2q उदाहरणों और वर्तमान मॉडल समर्थन मैट्रिक्स के लिए उपयुक्त है, देखें क्वालकॉम क्लाउड AI100 दस्तावेज़ीकरण.

अब उपलब्ध है

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

DL2q इंस्टेंसेस का उपयोग करके तैनात किया जा सकता है एडब्ल्यूएस डीप लर्निंग एएमआई (डीएलएएमआई), और कंटेनर छवियां प्रबंधित सेवाओं जैसे के माध्यम से उपलब्ध हैं अमेज़न SageMaker, अमेज़ॅन इलास्टिक कुबेरनेट्स सेवा (अमेज़ॅन ईकेएस), अमेज़न इलास्टिक कंटेनर सेवा (Amazon ECS), तथा एडब्ल्यूएस समानांतर क्लस्टर.

अधिक जानने के लिए, पर जाएँ अमेज़न EC2 DL2q उदाहरण पृष्ठ, और प्रतिक्रिया भेजें AWS पुन: EC2 के लिए पोस्ट करें या अपने सामान्य AWS समर्थन संपर्कों के माध्यम से।

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

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

जियानिंग लैंग AWS वर्ल्डवाइड स्पेशलिस्ट ऑर्गनाइजेशन (WWSO) में एक प्रिंसिपल सॉल्यूशंस आर्किटेक्ट हैं। उनके पास एचपीसी और एआई क्षेत्र में 15 वर्षों से अधिक का कार्य अनुभव है। AWS में, वह ग्राहकों को त्वरित कंप्यूटिंग इंस्टेंसेस पर उनके AI/ML वर्कलोड को तैनात करने, अनुकूलित करने और स्केल करने में मदद करने पर ध्यान केंद्रित करती है। वह एचपीसी और एआई क्षेत्रों में तकनीकों के संयोजन को लेकर उत्साहित हैं। जियानयिंग के पास बोल्डर में कोलोराडो विश्वविद्यालय से कम्प्यूटेशनल भौतिकी में पीएचडी की डिग्री है।

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोडेटा.नेटवर्क वर्टिकल जेनरेटिव एआई। स्वयं को शक्तिवान बनाएं। यहां पहुंचें।
• प्लेटोआईस्ट्रीम। Web3 इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• प्लेटोईएसजी. कार्बन, क्लीनटेक, ऊर्जा, पर्यावरण, सौर, कचरा प्रबंधन। यहां पहुंचें।
• प्लेटोहेल्थ। बायोटेक और क्लिनिकल परीक्षण इंटेलिजेंस। यहां पहुंचें।
• स्रोत: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/