מופע אמזון EC2 DL2q להסקת AI חסכונית עם ביצועים גבוהים זמין כעת באופן כללי | שירותי האינטרנט של אמזון

זהו פוסט אורח מאת AK Roy מ-Qualcomm AI.

ענן מחשוב אלסטי של אמזון (אמזון EC2) מופעי DL2q, המופעלים על ידי מאיצים סטנדרטיים של Qualcomm AI 100, יכולים לשמש לפריסה יעילה של עומסי עבודה של למידה עמוקה (DL) בענן. הם יכולים לשמש גם לפיתוח ולאמת ביצועים ודיוק של עומסי עבודה של DL שייפרסו במכשירי קוואלקום. מופעי DL2q הם המופעים הראשונים שהביאו את הטכנולוגיה החכמה המלאכותית (AI) של קוואלקום לענן.

עם שמונה מאיצים של Qualcomm AI 100 Standard ו-128 GiB של זיכרון מאיץ כולל, לקוחות יכולים גם להשתמש במופעי DL2q כדי להריץ יישומי AI גנרטיביים פופולריים, כגון יצירת תוכן, סיכום טקסט ועוזרים וירטואליים, כמו גם יישומי AI קלאסיים לעיבוד שפה טבעית וראייה ממוחשבת. בנוסף, מאיצי קוואלקום AI 100 כוללים את אותה טכנולוגיית בינה מלאכותית המשמשת בסמארטפונים, נהיגה אוטונומית, מחשבים אישיים ואוזניות מציאות מורחבת, כך שניתן להשתמש במופעי DL2q לפיתוח ולאמת עומסי עבודה של בינה מלאכותית לפני הפריסה.

דגשים חדשים של מופע DL2q

כל מופע DL2q משלב שמונה מאיצים של Qualcomm Cloud AI100, עם ביצועים מצטברים של למעלה מ-2.8 PetaOps של ביצועי הסקת Int8 ו-1.4 PetaFlops של ביצועי הסקת FP16. למופע יש 112 ליבות AI מצטבר, קיבולת זיכרון מאיץ של 128 GB ורוחב פס זיכרון של 1.1 TB לשנייה.

לכל מופע DL2q 96 vCPUs, קיבולת זיכרון מערכת של 768 GB ותומך ברוחב פס רשת של 100 Gbps וכן Amazon Elastic Block Store (Amazon EBS) אחסון של 19 Gbps.

חדשנות מאיץ Qualcomm Cloud AI100

מאיץ ה-Cloud AI100 מערכת-על-שבב (SoC) הוא ארכיטקטורה מרובת ליבות ניתנת להרחבה נבנית במיוחד, התומכת במגוון רחב של מקרי שימוש ללמידה עמוקה החל ממרכז הנתונים ועד לקצה. ה-SoC משתמש בליבות מחשוב סקלריות, וקטוריות וטנזוריות עם קיבולת SRAM מובילה בתעשייה של 126 MB. הליבות מחוברות זו לזו עם רשת רשת-על-שבב (NoC) ברוחב פס גבוה עם חביון נמוך.

מאיץ ה-AI100 תומך במגוון רחב ומקיף של דגמים ומקרי שימוש. הטבלה שלהלן מדגישה את טווח התמיכה בדגם.

* רוב רשתות הרכב הן רשתות מורכבות המורכבות ממיזוג של רשתות בודדות.

ה-SRAM הגדול על גבי המאיץ DL2q מאפשר הטמעה יעילה של טכניקות ביצועים מתקדמות כגון דיוק מיקרו-אקספונט MX6 לאחסון המשקולות ודיוק מיקרו-מעריך MX9 לתקשורת מאיץ-מאיץ. טכנולוגיית המיקרו-אקספוננט מתוארת בהודעת התעשייה הבאה של Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA, ו-Qualcomm מייצרות את הדור הבא של פורמטי נתונים צרים מדויקים עבור AI » Open Compute Project.

משתמש המופע יכול להשתמש באסטרטגיה הבאה כדי למקסם את הביצועים לעלות:

• אחסן משקלים באמצעות דיוק המיקרו-אקספוננט MX6 בזיכרון ה-DDR המופעל על המאיץ. השימוש בדייקנות MX6 ממקסם את ניצול קיבולת הזיכרון הזמינה ואת רוחב הפס של הזיכרון כדי לספק תפוקה והשהייה מהטובים מסוגו.
• חישוב ב-FP16 כדי לספק את דיוק מקרה השימוש הנדרש, תוך שימוש ב-SRAM המשובח על-שבב ו-TOPs רזרביים בכרטיס, כדי ליישם ביצועים גבוהים של גרעיני MX6 עד FP16.
• השתמש באסטרטגיית אצווה אופטימלית ובגודל אצווה גבוה יותר על ידי שימוש ב-SRAM הגדול על-שבב הזמין כדי למקסם את השימוש החוזר במשקלים, תוך שמירה על ההפעלה על-שבב למקסימום האפשרי.

DL2q AI מחסנית ושרשרת כלים

מופע DL2q מלווה ב-Qualcomm AI Stack המספק חווית מפתח עקבית בכל קוואלקום AI בענן ובמוצרים אחרים של Qualcomm. אותה טכנולוגיית AI מחסנית ובסיס AI של Qualcomm פועלת על מופעי DL2q ומכשירי קוואלקום קצה, ומספקת ללקוחות חווית מפתח עקבית, עם API מאוחד על פני ענן, רכב, מחשב אישי, מציאות מורחבת וסביבות פיתוח סמארטפונים.

שרשרת הכלים מאפשרת למשתמש המופע להרכיב במהירות מודל שהוכשר בעבר, לקמפל ולבצע אופטימיזציה של המודל עבור יכולות המופע, ולאחר מכן לפרוס את המודלים שנערכו עבור מקרי שימוש בהסקת ייצור בשלושה שלבים המוצגים באיור הבא.

למידע נוסף על כוונון הביצועים של דגם, עיין ב- Cloud AI 100 פרמטרי ביצועים מרכזיים תיעוד.

התחל עם מופעי DL2q

בדוגמה זו, אתה קומפלט ופורס קובץ מאומן מראש דגם BERT החל מ- פנים מחבקות על מופע EC2 DL2q באמצעות DL2q AMI זמין בנוי מראש, בארבעה שלבים.

אתה יכול להשתמש באחד מראש קוואלקום DLAMI על המופע או התחל עם Amazon Linux2 AMI ובנה DL2q AMI משלך עם Cloud AI 100 Platform ו- Apps SDK הזמינים ב- שירות אחסון פשוט של אמזון (Amazon S3) דְלִי: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

השלבים הבאים משתמשים ב-DL2q AMI המובנה מראש, Qualcomm Base AL2 DLAMI.

השתמש ב-SSH כדי לגשת למופע DL2q שלך עם Qualcomm Base AL2 DLAMI AMI ובצע את השלבים 1 עד 4.

שלב 1. הגדר את הסביבה והתקן את החבילות הנדרשות

1. התקן את Python 3.8.

   sudo amazon-linux-extras install python3.8

2. הגדר את הסביבה הווירטואלית Python 3.8.

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

3. הפעל את הסביבה הוירטואלית Python 3.8.

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

4. התקן את החבילות הנדרשות, המוצגות ב- מסמך requirements.txt זמין באתר Github הציבורי של קוואלקום.

   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. הרכיב את המודל

השמיים qaic-exec כלי המהדר של ממשק שורת הפקודה (CLI) משמש להידור המודל. הקלט למהדר זה הוא קובץ ONNX שנוצר בשלב 2. המהדר מייצר קובץ בינארי (נקרא QPC, עבור מיכל תוכנית קוואלקום) בנתיב שהוגדר על ידי -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. הפעל את המודל

הגדר הפעלה כדי להפעיל את ההסקה על מאיץ Cloud AI100 Qualcomm במופע DL2q.

ספריית Qualcomm qaic Python היא קבוצה של ממשקי API המספקים תמיכה להרצת הסקת מסקנות על מאיץ Cloud AI100.

1. השתמש בקריאה ל-Session API כדי ליצור מופע של הפעלה. הקריאה ל-Session API היא נקודת הכניסה לשימוש בספריית ה-qaic Python.

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

להלן הפלטים עבור משפט הקלט "הכלב [מסכה] על המחצלת."

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)

זהו זה. עם כמה שלבים בלבד, הידור והרצת מודל PyTorch על מופע של Amazon EC2 DL2q. למידע נוסף על שילוב וקומפילציה של מודלים במופע DL2q, עיין ב- תיעוד הדרכה של Cloud AI100.

למידע נוסף על אילו ארכיטקטורות מודל DL מתאימות למופעי AWS DL2q ומטריצת תמיכת המודל הנוכחית, עיין ב- תיעוד Qualcomm Cloud AI100.

זמין כעת

אתה יכול להשיק מופעי DL2q היום באזורי AWS במערב ארה"ב (אורגון) ואירופה (פרנקפורט). לפי דרישה, שמורות, ו מופעי ספוט, או במסגרת א תכנית חיסכון. כרגיל באמזון EC2, אתה משלם רק על מה שאתה משתמש בו. למידע נוסף, ראה תמחור אמזון EC2.

ניתן לפרוס מופעי DL2q באמצעות AWS למידה עמוקה AMI (DLAMI), ותמונות מיכל זמינות דרך שירותים מנוהלים כגון אמזון SageMaker, Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Elastic Container Service (Amazon ECS), ו ParallelCluster של AWS.

למידע נוסף, בקר בכתובת מופע של Amazon EC2 DL2q עמוד, ושלח משוב אל AWS re:Post עבור EC2 או דרך אנשי הקשר הרגילים שלך לתמיכה של AWS.

על המחברים

א.ק רוי הוא מנהל ניהול מוצר ב-Qualcomm, עבור מוצרים ופתרונות בינה מלאכותית של ענן ו-Datacenter. יש לו למעלה מ-20 שנות ניסיון באסטרטגיית ופיתוח מוצר, עם המוקד הנוכחי של ביצועים וביצועים מהטובים בכיתה/פתרונות מקצה לקצה עבור מסקנות AI בענן, עבור מגוון רחב של מקרי שימוש, כולל GenAI, LLMs, Auto ו-Hybrid AI.

ג'יאניינג לאנג הוא אדריכל פתרונות ראשי ב-AWS Worldwide Specialist Organization (WWSO). יש לה למעלה מ-15 שנות ניסיון בעבודה בתחום HPC ובינה מלאכותית. ב-AWS, היא מתמקדת בסיוע ללקוחות לפרוס, לייעל ולהרחיב את עומסי העבודה של AI/ML שלהם במופעי מחשוב מואצים. היא נלהבת משילוב הטכניקות בתחומי HPC ו-AI. ל-Jianying תואר דוקטור בפיזיקה חישובית מאוניברסיטת קולורדו בבולדר.

• הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
• PlatoData.Network Vertical Generative Ai. העצים את עצמך. גישה כאן.
• PlatoAiStream. Web3 Intelligence. הידע מוגבר. גישה כאן.
• PlatoESG. פחמן, קלינטק, אנרגיה, סביבה, שמש, ניהול פסולת. גישה כאן.
• PlatoHealth. מודיעין ביוטכנולוגיה וניסויים קליניים. גישה כאן.
• מקור: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/