อินสแตนซ์ Amazon EC2 DL2q สำหรับการอนุมาน AI ประสิทธิภาพสูงและคุ้มต้นทุนพร้อมใช้งานโดยทั่วไปแล้ว | อเมซอนเว็บเซอร์วิส

นี่คือแขกโพสต์โดย AK Roy จาก Qualcomm AI

Amazon Elastic Compute Cloud (อเมซอน EC2) อินสแตนซ์ DL2q ซึ่งขับเคลื่อนโดยตัวเร่งความเร็วมาตรฐาน Qualcomm AI 100 สามารถใช้เพื่อปรับใช้ปริมาณงานการเรียนรู้เชิงลึก (DL) ในระบบคลาวด์ได้อย่างคุ้มต้นทุน นอกจากนี้ยังสามารถใช้เพื่อพัฒนาและตรวจสอบประสิทธิภาพและความแม่นยำของปริมาณงาน DL ที่จะปรับใช้บนอุปกรณ์ Qualcomm อินสแตนซ์ DL2q เป็นอินสแตนซ์แรกที่นำเทคโนโลยีปัญญาประดิษฐ์ (AI) ของ Qualcomm มาสู่ระบบคลาวด์

ด้วยตัวเร่งความเร็วมาตรฐาน Qualcomm AI 100 Standard แปดตัวและหน่วยความจำตัวเร่งทั้งหมด 128 GiB ลูกค้ายังสามารถใช้อินสแตนซ์ DL2q เพื่อรันแอปพลิเคชัน AI เจนเนอเรชั่นยอดนิยม เช่น การสร้างเนื้อหา การสรุปข้อความ และผู้ช่วยเสมือน รวมถึงแอปพลิเคชัน AI แบบคลาสสิกสำหรับการประมวลผลภาษาธรรมชาติ และการมองเห็นของคอมพิวเตอร์ นอกจากนี้ ตัวเร่งความเร็ว Qualcomm AI 100 ยังมีเทคโนโลยี AI แบบเดียวกับที่ใช้ในสมาร์ทโฟน การขับขี่อัตโนมัติ คอมพิวเตอร์ส่วนบุคคล และชุดหูฟังความเป็นจริงเสริม ดังนั้นอินสแตนซ์ DL2q จึงสามารถใช้เพื่อพัฒนาและตรวจสอบปริมาณงาน AI เหล่านี้ก่อนปรับใช้ได้

ไฮไลท์อินสแตนซ์ DL2q ใหม่

อินสแตนซ์ DL2q แต่ละตัวประกอบด้วยตัวเร่งความเร็ว Qualcomm Cloud AI100 แปดตัว โดยมีประสิทธิภาพรวมมากกว่า 2.8 PetaOps ของประสิทธิภาพการอนุมาน Int8 และ 1.4 PetaFlops ของประสิทธิภาพการอนุมาน FP16 อินสแตนซ์นี้มีคอร์ AI รวม 112 คอร์ ความจุหน่วยความจำเร่งความเร็ว 128 GB และแบนด์วิดท์หน่วยความจำ 1.1 TB ต่อวินาที

อินสแตนซ์ DL2q แต่ละตัวมี vCPU 96 ตัว ความจุหน่วยความจำระบบ 768 GB และรองรับแบนด์วิธเครือข่าย 100 Gbps รวมถึง ร้านค้า Amazon Elastic Block (Amazon EBS) พื้นที่เก็บข้อมูล 19 Gbps

นวัตกรรมตัวเร่ง Qualcomm Cloud AI100

ระบบบนชิป (SoC) ตัวเร่ง Cloud AI100 เป็นสถาปัตยกรรมแบบมัลติคอร์ที่สร้างขึ้นตามวัตถุประสงค์และปรับขนาดได้ โดยรองรับกรณีการใช้งานการเรียนรู้เชิงลึกที่หลากหลายตั้งแต่ศูนย์ข้อมูลไปจนถึง Edge SoC ใช้แกนประมวลผลแบบสเกลาร์ เวกเตอร์ และเทนเซอร์ พร้อมด้วยความจุ SRAM on-die ชั้นนำของอุตสาหกรรมที่ 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 บนชิปที่เหนือกว่าและ TOP สำรองบนการ์ด เพื่อใช้เคอร์เนล MX6 ที่มีความหน่วงต่ำประสิทธิภาพสูง
• ใช้กลยุทธ์การจัดชุดที่ได้รับการปรับปรุงและขนาดชุดงานที่สูงขึ้นโดยใช้ SRAM บนชิปขนาดใหญ่ที่มีอยู่เพื่อเพิ่มการใช้ตุ้มน้ำหนักซ้ำให้เกิดประโยชน์สูงสุด ขณะเดียวกันก็รักษาการเปิดใช้งานบนชิปไว้ให้มากที่สุดเท่าที่จะเป็นไปได้

DL2q AI Stack และ toolchain

อินสแตนซ์ DL2q มาพร้อมกับ Qualcomm AI Stack ที่มอบประสบการณ์นักพัฒนาที่สอดคล้องกันใน Qualcomm AI ในระบบคลาวด์และผลิตภัณฑ์ Qualcomm อื่นๆ เทคโนโลยี AI สแต็กและฐานของ Qualcomm AI แบบเดียวกันนั้นทำงานบนอินสแตนซ์ DL2q และอุปกรณ์ Qualcomm Edge ช่วยให้ลูกค้าได้รับประสบการณ์นักพัฒนาที่สอดคล้องกัน ด้วย API แบบรวมทั่วทั้งระบบคลาวด์ ยานยนต์ คอมพิวเตอร์ส่วนบุคคล Extended Reality และสภาพแวดล้อมการพัฒนาสมาร์ทโฟน

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

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการปรับแต่งประสิทธิภาพของโมเดล โปรดดูที่ พารามิเตอร์ประสิทธิภาพหลักของ Cloud AI 100 เอกสาร

เริ่มต้นใช้งานอินสแตนซ์ DL2q

ในตัวอย่างนี้ คุณคอมไพล์และปรับใช้โปรแกรมที่ได้รับการฝึกอบรมล่วงหน้า รุ่น BERT ราคาเริ่มต้นที่ กอดหน้า บนอินสแตนซ์ EC2 DL2q โดยใช้ DL2q AMI ที่สร้างไว้ล่วงหน้าที่พร้อมใช้งานในสี่ขั้นตอน

คุณสามารถใช้อย่างใดอย่างหนึ่งที่สร้างไว้ล่วงหน้า ควอลคอมม์ ดลามี บนอินสแตนซ์หรือเริ่มต้นด้วย Amazon Linux2 AMI และสร้าง DL2q AMI ของคุณเองด้วย Cloud AI 100 Platform และ Apps SDK ที่มีอยู่ในนี้ บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ถัง: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

ขั้นตอนที่ตามมาใช้ DL2q AMI ที่สร้างไว้ล่วงหน้า ฐาน Qualcomm 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. ติดตั้งแพ็คเกจที่จำเป็น ดังแสดงในไฟล์ เอกสารข้อกำหนด.txt สามารถดูได้ที่ไซต์ Github สาธารณะของ Qualcomm

   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 คอมไพเลอร์สร้างไฟล์ไบนารี (เรียกว่า คิวพีซีสำหรับ คอนเทนเนอร์โปรแกรม Qualcomm) ในเส้นทางที่กำหนดโดย -aic-binary-dir ข้อโต้แย้ง.

ในคำสั่งคอมไพล์ด้านล่าง คุณใช้คอร์ประมวลผล AI สี่คอร์และขนาดแบทช์หนึ่งคอร์ในการคอมไพล์โมเดล

/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 accelerator

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

ต่อไปนี้เป็นผลลัพธ์ของประโยคอินพุต “The dog [MASK] on the mat”

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 ของสหรัฐอเมริกาฝั่งตะวันตก (ออริกอน) และยุโรป (แฟรงก์เฟิร์ต) ตามความต้องการ, ที่สงวนไว้และ อินสแตนซ์ของสปอตหรือเป็นส่วนหนึ่งของ แผนการออม. ตามปกติสำหรับ Amazon EC2 คุณจะจ่ายเฉพาะส่วนที่คุณใช้เท่านั้น สำหรับข้อมูลเพิ่มเติม โปรดดู ราคา Amazon EC2.

สามารถปรับใช้อินสแตนซ์ DL2q ได้ AWS Deep Learning AMI (DLAMI)และอิมเมจคอนเทนเนอร์พร้อมใช้งานผ่านบริการที่มีการจัดการ เช่น อเมซอน SageMaker, บริการ Amazon Elastic Kubernetes (Amazon EKS), บริการ Amazon Elastic Container (Amazon ECS)และ AWS ParallelCluster.

หากต้องการเรียนรู้เพิ่มเติมโปรดไปที่ อินสแตนซ์ Amazon EC2 DL2q เพจ และส่งข้อเสนอแนะมาที่ AWS re:Post สำหรับ EC2 หรือผ่านผู้ติดต่อ AWS Support ปกติของคุณ

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

เอเค รอย เป็นผู้อำนวยการฝ่ายการจัดการผลิตภัณฑ์ที่ Qualcomm สำหรับผลิตภัณฑ์และโซลูชัน Cloud และ Datacenter AI เขามีประสบการณ์มากกว่า 20 ปีในด้านกลยุทธ์และการพัฒนาผลิตภัณฑ์ โดยปัจจุบันมุ่งเน้นไปที่ประสิทธิภาพและประสิทธิภาพที่ดีที่สุดในระดับเดียวกัน/$ โซลูชัน end-to-end สำหรับการอนุมาน AI ในระบบคลาวด์ สำหรับกรณีการใช้งานที่หลากหลาย รวมถึง GenAI, LLM, Auto และ Hybrid AI

เจียนหยิง หลาง เป็น Principal Solutions Architect ที่ AWS Worldwide Specialist Organisation (WWSO) เธอมีประสบการณ์การทำงานมากกว่า 15 ปีในด้าน HPC และ AI ที่ AWS เธอมุ่งเน้นไปที่การช่วยเหลือลูกค้าปรับใช้ เพิ่มประสิทธิภาพ และปรับขนาดปริมาณงาน AI/ML บนอินสแตนซ์การประมวลผลแบบเร่งความเร็ว เธอมีความหลงใหลในการผสานเทคนิคในด้าน HPC และ AI Jianying สำเร็จการศึกษาระดับปริญญาเอกสาขาฟิสิกส์คอมพิวเตอร์จากมหาวิทยาลัยโคโลราโดที่โบลเดอร์

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• PlatoData.Network Vertical Generative Ai เพิ่มพลังให้กับตัวเอง เข้าถึงได้ที่นี่.
• เพลโตไอสตรีม. Web3 อัจฉริยะ ขยายความรู้ เข้าถึงได้ที่นี่.
• เพลโตESG. คาร์บอน, คลีนเทค, พลังงาน, สิ่งแวดล้อม แสงอาทิตย์, การจัดการของเสีย. เข้าถึงได้ที่นี่.
• เพลโตสุขภาพ เทคโนโลยีชีวภาพและข่าวกรองการทดลองทางคลินิก เข้าถึงได้ที่นี่.
• ที่มา: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/