เรียกใช้โมเดลการเรียนรู้เชิงลึกหลายรายการบน GPU ด้วยตำแหน่งข้อมูลหลายรุ่นของ Amazon SageMaker

ในขณะที่การนำ AI มาใช้นั้นกำลังเพิ่มขึ้นทั่วทั้งอุตสาหกรรม ลูกค้ากำลังสร้างแบบจำลองที่ซับซ้อนซึ่งใช้ประโยชน์จากความก้าวหน้าทางวิทยาศาสตร์ครั้งใหม่ในการเรียนรู้เชิงลึก โมเดลรุ่นต่อไปเหล่านี้ช่วยให้คุณบรรลุประสิทธิภาพที่ล้ำสมัยเหมือนมนุษย์ในด้านการประมวลผลภาษาธรรมชาติ (NLP) คอมพิวเตอร์วิทัศน์ การรู้จำเสียง การวิจัยทางการแพทย์ ความปลอดภัยทางไซเบอร์ การทำนายโครงสร้างโปรตีน และอื่นๆ อีกมากมาย . ตัวอย่างเช่น โมเดลภาษาขนาดใหญ่ เช่น GPT-3, OPT และ BLOOM สามารถแปล สรุป และเขียนข้อความด้วยความแตกต่างที่คล้ายคลึงกันของมนุษย์ ในพื้นที่การมองเห็นด้วยคอมพิวเตอร์ แบบจำลองการแพร่กระจายข้อความเป็นรูปภาพ เช่น DALL-E และ Imagen สามารถสร้างภาพที่เหมือนจริงจากภาษาธรรมชาติด้วยระดับความเข้าใจด้านภาพและภาษาที่สูงขึ้นจากโลกรอบตัวเรา โมเดลหลายโมดอลเหล่านี้มีคุณสมบัติที่สมบูรณ์ยิ่งขึ้นสำหรับงานดาวน์สตรีมต่างๆ และความสามารถในการปรับแต่งสำหรับโดเมนเฉพาะ และนำโอกาสทางธุรกิจอันทรงพลังมาสู่ลูกค้าของเรา

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

อเมซอน SageMaker อุปกรณ์ปลายทางหลายรุ่น (MME) เป็นวิธีที่ปรับขนาดได้และคุ้มค่าในการปรับใช้โมเดลการเรียนรู้เชิงลึกจำนวนมาก MME เป็นตัวเลือกโฮสติ้งที่ได้รับความนิยมในการโฮสต์โมเดลที่ใช้ CPU หลายร้อยรุ่นในหมู่ลูกค้าเช่น Zendesk, Veeva และ AT&T ก่อนหน้านี้ คุณมีตัวเลือกที่จำกัดในการปรับใช้โมเดลการเรียนรู้เชิงลึกหลายร้อยแบบซึ่งจำเป็นต้องเร่งการประมวลผลด้วย GPU วันนี้เราประกาศการรองรับ MME สำหรับ GPU ตอนนี้คุณสามารถปรับใช้โมเดลการเรียนรู้เชิงลึกนับพันหลังจุดสิ้นสุด SageMaker ได้ ขณะนี้ MME สามารถเรียกใช้โมเดลได้หลายรุ่นบนแกน GPU แชร์อินสแตนซ์ GPU เบื้องหลังปลายทางในหลายรุ่น และโหลดและยกเลิกการโหลดโมเดลแบบไดนามิกตามการรับส่งข้อมูลขาเข้า ด้วยสิ่งนี้ คุณสามารถประหยัดต้นทุนได้อย่างมากและได้ประสิทธิภาพราคาดีที่สุด

ในโพสต์นี้ เราจะแสดงวิธีเรียกใช้โมเดลการเรียนรู้เชิงลึกหลายแบบบน GPU ด้วย SageMaker MME

MME ของ SageMaker

SageMaker MME ช่วยให้คุณสามารถปรับใช้หลายรุ่นหลังจุดสิ้นสุดการอนุมานเดียวที่อาจมีอย่างน้อยหนึ่งอินสแตนซ์ ด้วย MME แต่ละอินสแตนซ์สามารถโหลดและให้บริการได้หลายรุ่น MME ช่วยให้คุณตัดค่าใช้จ่ายที่เพิ่มขึ้นเชิงเส้นตรงของการโฮสต์หลายรุ่นและนำโครงสร้างพื้นฐานกลับมาใช้ใหม่ได้ในทุกโมเดล

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมของ SageMaker MME

SageMaker MME ดาวน์โหลดโมเดลแบบไดนามิกจาก บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) เมื่อเรียกใช้ แทนที่จะดาวน์โหลดโมเดลทั้งหมดเมื่อสร้างจุดสิ้นสุดในครั้งแรก ด้วยเหตุนี้ การเรียกใช้เริ่มต้นกับโมเดลอาจเห็นเวลาแฝงการอนุมานที่สูงกว่าการอนุมานที่ตามมา ซึ่งเสร็จสิ้นโดยมีเวลาแฝงต่ำ หากโมเดลโหลดบนคอนเทนเนอร์แล้วเมื่อเรียกใช้ ขั้นตอนการดาวน์โหลดและโหลดจะถูกข้าม และโมเดลจะส่งคืนการอนุมานที่มีเวลาแฝงต่ำ ตัวอย่างเช่น สมมติว่าคุณมีแบบจำลองที่ใช้เพียงไม่กี่ครั้งต่อวัน โดยจะโหลดโดยอัตโนมัติตามต้องการ ในขณะที่รุ่นที่เข้าถึงบ่อยจะถูกเก็บไว้ในหน่วยความจำและเรียกใช้โดยมีเวลาแฝงต่ำอย่างสม่ำเสมอ

SageMaker MME พร้อมรองรับ GPU

SageMaker MME กับ GPU ทำงานโดยใช้ เซิร์ฟเวอร์การอนุมาน NVIDIA Triton. เซิร์ฟเวอร์ NVIDIA Triton Inference เป็นซอฟต์แวร์ที่ให้บริการการอนุมานแบบโอเพนซอร์สที่ทำให้กระบวนการอนุมานง่ายขึ้นและให้ประสิทธิภาพการอนุมานสูง Triton รองรับเฟรมเวิร์กการฝึกอบรมและการอนุมานที่สำคัญทั้งหมด เช่น TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, C++ แบบกำหนดเอง และอื่นๆ นำเสนอชุดงานแบบไดนามิก การทำงานพร้อมกัน การหาปริมาณหลังการฝึก และการกำหนดค่าแบบจำลองที่เหมาะสมที่สุดเพื่อให้เกิดการอนุมานที่มีประสิทธิภาพสูง นอกจากนี้ เซิร์ฟเวอร์ NVIDIA Triton Inference ยังได้รับการขยายการใช้งาน สัญญา MME APIเพื่อบูรณาการเข้ากับ MME

ไดอะแกรมต่อไปนี้แสดงเวิร์กโฟลว์ MME

ขั้นตอนเวิร์กโฟลว์มีดังนี้:

1. SageMaker MME ได้รับคำขอเรียกใช้ HTTP สำหรับรุ่นเฉพาะโดยใช้ TargetModel ในคำขอพร้อมกับเพย์โหลด
2. SageMaker กำหนดเส้นทางการรับส่งข้อมูลไปยังอินสแตนซ์ที่ถูกต้องด้านหลังปลายทางที่โหลดโมเดลเป้าหมาย SageMaker เข้าใจรูปแบบการรับส่งข้อมูลในทุกรุ่นที่อยู่เบื้องหลัง MME และกำหนดเส้นทางคำขออย่างชาญฉลาด
3. SageMaker ดูแลการจัดการโมเดลเบื้องหลังปลายทาง โหลดโมเดลไปยังหน่วยความจำของคอนเทนเนอร์แบบไดนามิก และยกเลิกการโหลดโมเดลตามกลุ่มอินสแตนซ์ GPU ที่ใช้ร่วมกันเพื่อให้ราคามีประสิทธิภาพสูงสุด
4. SageMaker ดาวน์โหลดโมเดลแบบไดนามิกจาก Amazon S3 ไปยังโวลุ่มพื้นที่จัดเก็บของอินสแตนซ์ หากไม่มีโมเดลที่เรียกใช้บนโวลุ่มพื้นที่จัดเก็บอินสแตนซ์ โมเดลนั้นจะถูกดาวน์โหลดลงในโวลุ่มพื้นที่จัดเก็บอินสแตนซ์ หากปริมาณพื้นที่จัดเก็บอินสแตนซ์ถึงความจุ SageMaker จะลบโมเดลที่ไม่ได้ใช้ออกจากโวลุ่มพื้นที่จัดเก็บ
5. SageMaker โหลดโมเดลไปยังหน่วยความจำของคอนเทนเนอร์ NVIDIA Triton บนอินสแตนซ์ที่เร่งความเร็วของ GPU และให้บริการคำขออนุมาน คอร์ GPU ถูกแชร์โดยทุกรุ่นในอินสแตนซ์ หากโหลดโมเดลในหน่วยความจำคอนเทนเนอร์แล้ว คำขอที่ตามมาจะได้รับบริการเร็วขึ้นเนื่องจาก SageMaker ไม่จำเป็นต้องดาวน์โหลดและโหลดอีกครั้ง
6. SageMaker ดูแลการกำหนดรูปแบบการรับส่งข้อมูลไปยังปลายทาง MME และรักษาสำเนาแบบจำลองที่เหมาะสมที่สุดบนอินสแตนซ์ GPU เพื่อประสิทธิภาพราคาดีที่สุด มันยังคงกำหนดเส้นทางการรับส่งข้อมูลไปยังอินสแตนซ์ที่มีการโหลดโมเดล หากทรัพยากรอินสแตนซ์ถึงความจุเนื่องจากมีการใช้ประโยชน์สูง SageMaker จะยกเลิกการโหลดโมเดลที่ใช้น้อยที่สุดจากคอนเทนเนอร์เพื่อเพิ่มทรัพยากรเพื่อโหลดโมเดลที่ใช้บ่อยขึ้น

SageMaker MME สามารถปรับขนาดในแนวนอนได้โดยใช้นโยบายการปรับขนาดอัตโนมัติ และจัดเตรียมอินสแตนซ์การประมวลผล GPU เพิ่มเติมตามตัวชี้วัด เช่น การเรียกใช้ต่ออินสแตนซ์และการใช้ GPU เพื่อรองรับการรับส่งข้อมูลที่เพิ่มขึ้นไปยังปลายทาง MME

ภาพรวมโซลูชัน

ในโพสต์นี้ เราจะแสดงให้คุณเห็นถึงวิธีใช้คุณสมบัติใหม่ของ SageMaker MME กับ GPU พร้อมกรณีการใช้งานคอมพิวเตอร์วิทัศน์ เพื่อจุดประสงค์ในการสาธิต เราใช้โมเดล Pre-trained ของโครงข่ายประสาทเทียม ResNet-50 ที่สามารถจำแนกรูปภาพออกเป็น 1,000 หมวดหมู่ เราหารือเกี่ยวกับวิธีการทำดังต่อไปนี้:

• ใช้คอนเทนเนอร์อนุมาน NVIDIA Triton บน SageMaker MME โดยใช้แบ็กเอนด์เฟรมเวิร์กโมเดล Triton ที่แตกต่างกัน และ PyTorch และ TensorRT
• แปลงโมเดล ResNet-50 เป็นรูปแบบเอ็นจิ้น TensorRT ที่ปรับให้เหมาะสมและปรับใช้ด้วย SageMaker MME
• ตั้งค่านโยบายการปรับขนาดอัตโนมัติสำหรับ MME
• รับข้อมูลเชิงลึกเกี่ยวกับอินสแตนซ์และตัววัดการเรียกใช้โดยใช้ อเมซอน คลาวด์วอตช์

สร้างแบบจำลองสิ่งประดิษฐ์

ส่วนนี้จะอธิบายขั้นตอนต่างๆ ในการเตรียมโมเดล Pre-trained ResNet-50 เพื่อปรับใช้บน SageMaker MME โดยใช้การกำหนดค่าโมเดล Triton Inference Server คุณสามารถทำซ้ำขั้นตอนทั้งหมดโดยใช้สมุดบันทึกทีละขั้นตอนบน GitHub.

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

เตรียมโมเดล PyTorch

ขั้นแรก เราโหลดโมเดล ResNet50 ที่ฝึกไว้ล่วงหน้าโดยใช้แพ็คเกจรุ่น Torchvision เราบันทึกโมเดลเป็นไฟล์ model.pt ในรูปแบบ TorchScript ที่ปรับให้เหมาะสมและเป็นอนุกรม TorchScript รวบรวมการส่งต่อของรุ่น ResNet50 ในโหมดกระตือรือร้นพร้อมตัวอย่างอินพุต ดังนั้นเราจึงส่งหนึ่งอินสแตนซ์ของภาพ RGB ที่มีช่องสีสามช่องขนาด 224 x 224

จากนั้นเราต้องเตรียมโมเดลสำหรับ Triton Inference Server โค้ดต่อไปนี้แสดงที่เก็บโมเดลสำหรับแบ็กเอนด์เฟรมเวิร์ก PyTorch Triton ใช้ไฟล์ model.pt ที่วางอยู่ในที่เก็บโมเดลเพื่อให้บริการการคาดคะเน

resnet
├── 1
│   └── model.pt
└── config.pbtxt

ไฟล์คอนฟิกูเรชันโมเดล config.pbtxt ต้องระบุชื่อรุ่น (resnet) คุณสมบัติของแพลตฟอร์มและแบ็กเอนด์ (pytorch_libtorch), max_batch_size (128) และเทนเซอร์อินพุตและเอาต์พุตพร้อมกับชนิดข้อมูล (TYPE_FP32) ข้อมูล. นอกจากนี้ คุณสามารถระบุ instance_group และ dynamic_batching คุณสมบัติเพื่อการอนุมานที่มีประสิทธิภาพสูง ดูรหัสต่อไปนี้:

name: "resnet"
platform: "pytorch_libtorch"
max_batch_size: 128
input {
  name: "INPUT__0"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "OUTPUT__0"
  data_type: TYPE_FP32
  dims: 1000
}

เตรียมโมเดล TensorRT

NVIDIA TensorRT เป็น SDK สำหรับการอนุมานการเรียนรู้เชิงลึกที่มีประสิทธิภาพสูง และรวมถึงเครื่องมือเพิ่มประสิทธิภาพการอนุมานเชิงลึกและรันไทม์ที่ให้เวลาแฝงต่ำและปริมาณงานสูงสำหรับแอปพลิเคชันการอนุมาน เราใช้เครื่องมือบรรทัดคำสั่ง trtexec เพื่อสร้างเอ็นจิ้น TensorRT ที่ซีเรียลไลซ์จาก an ออนเอ็นเอ็กซ์ รูปแบบโมเดล ทำตามขั้นตอนต่อไปนี้เพื่อแปลงโมเดล Pre-trained ResNet-50 เป็น NVIDIA TensorRT:

1. ส่งออกโมเดล ResNet-50 ที่ได้รับการฝึกมาล่วงหน้าเป็นรูปแบบ ONNX โดยใช้ ไฟฉาย.onnx. ขั้นตอนนี้รันโมเดลหนึ่งครั้งเพื่อติดตามรันด้วยอินพุตตัวอย่าง จากนั้นเอ็กซ์พอร์ตโมเดลที่ติดตามไปยังไฟล์ที่ระบุ model.onnx.
2. ใช้ trtexec เพื่อสร้างแผนเอ็นจิ้น TensorRT จาก model.onnx ไฟล์. คุณสามารถเลือกลดความแม่นยำของการคำนวณแบบทศนิยมได้ โดยการเรียกใช้ในจุดทศนิยม 16 บิต หรือโดยการหาค่าจุดทศนิยมเพื่อให้การคำนวณสามารถทำได้โดยใช้จำนวนเต็ม 8 บิต

โค้ดต่อไปนี้แสดงโครงสร้างที่เก็บโมเดลสำหรับโมเดล TensorRT:

resnet
├── 1
│   └── model.plan
└── config.pbtxt

สำหรับโมเดล TensorRT เราระบุ tensorrt_plan เป็นแพลตฟอร์มและป้อนข้อกำหนดเทนเซอร์ของภาพขนาด 224 x 224 ซึ่งมีช่องสี เทนเซอร์เอาต์พุตที่มี 1,000 มิติเป็นประเภท TYPE_FP32สอดคล้องกับหมวดหมู่อ็อบเจ็กต์ต่างๆ ดูรหัสต่อไปนี้:

name: "resnet"
platform: "tensorrt_plan"
max_batch_size: 128
input {
  name: "input"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "output"
  data_type: TYPE_FP32
  dims: 1000
}
model_warmup {
    name: "bs128 Warmup"
    batch_size: 128
    inputs: {
        key: "input"
        value: {
            data_type: TYPE_FP32
            dims: 3
            dims: 224
            dims: 224
            zero_data: false
        }
    }
}

จัดเก็บสิ่งประดิษฐ์ของโมเดลใน Amazon S3

SageMaker คาดหวังสิ่งประดิษฐ์ของโมเดลใน .tar.gz รูปแบบ. นอกจากนี้ยังควรเป็นไปตามข้อกำหนดของคอนเทนเนอร์ไทรทัน เช่น ชื่อรุ่น รุ่น config.pbtxt ไฟล์ และอื่นๆ tar โฟลเดอร์ที่มีไฟล์โมเดลเป็น .tar.gz และอัปโหลดไปยัง Amazon S3:

!mkdir -p triton-serve-pt/resnet/1/
!mv -f workspace/model.pt triton-serve-pt/resnet/1/
!tar -C triton-serve-pt/ -czf resnet_pt_v0.tar.gz resnet
model_uri_pt = sagemaker_session.upload_data(path="resnet_pt_v0.tar.gz", key_prefix="resnet-mme-gpu")
!mkdir -p triton-serve-trt/resnet/1/
!mv -f workspace/model.plan triton-serve-trt/resnet/1/
!tar -C triton-serve-trt/ -czf resnet_trt_v0.tar.gz resnet
model_uri_trt = sagemaker_session.upload_data(path="resnet_trt_v0.tar.gz", key_prefix="resnet-mme-gpu")

ตอนนี้เราได้อัปโหลดสิ่งประดิษฐ์ของโมเดลไปยัง Amazon S3 แล้ว เราจึงสามารถสร้าง SageMaker MME ได้

ปรับใช้โมเดลด้วย MME

ตอนนี้เราปรับใช้โมเดล ResNet-50 ที่มีแบ็กเอนด์เฟรมเวิร์กที่แตกต่างกันสองแบบ (PyTorch และ TensorRT) กับ SageMaker MME

โปรดทราบว่าคุณสามารถปรับใช้โมเดลได้หลายร้อยแบบ และโมเดลสามารถใช้เฟรมเวิร์กเดียวกันได้ พวกเขายังสามารถใช้เฟรมเวิร์กต่างๆ ตามที่แสดงในโพสต์นี้

เราใช้ AWS SDK สำหรับ Python (Boto3) APIs create_model, create_endpoint_configและ create_endpoint เพื่อสร้าง MME

กำหนดภาชนะที่ให้บริการ

ในนิยามคอนเทนเนอร์ ให้นิยาม model_data_url เพื่อระบุไดเร็กทอรี S3 ที่มีโมเดลทั้งหมดที่ SageMaker MME ใช้ในการโหลดและให้บริการการคาดคะเน ชุด Mode ไปยัง MultiModel เพื่อระบุว่า SageMaker สร้างปลายทางด้วยข้อกำหนดคอนเทนเนอร์ MME เราตั้งค่าคอนเทนเนอร์ด้วยอิมเมจที่รองรับการปรับใช้ MME กับ GPU ดูรหัสต่อไปนี้:

container = {
"Image": ,
"ModelDataUrl": ,
"Mode": "MultiModel"
}

สร้างวัตถุหลายรุ่น

ใช้ไคลเอ็นต์ SageMaker Boto3 เพื่อสร้างโมเดลโดยใช้ create_model เอพีไอ เราส่งคำจำกัดความคอนเทนเนอร์ไปยัง API สร้างโมเดลพร้อมกับ ModelName และ ExecutionRoleArn:

create_model_response = sm_client.create_model(
    ModelName=, ExecutionRoleArn=role, PrimaryContainer=container
)

กำหนดการกำหนดค่า MME

สร้างการกำหนดค่า MME โดยใช้ create_endpoint_config Boto3 API ระบุอินสแตนซ์การประมวลผล GPU แบบเร่งใน InstanceType (เราใช้ประเภทอินสแตนซ์ g4dn.4xlarge) เราแนะนำให้กำหนดค่าปลายทางของคุณด้วยอย่างน้อยสองอินสแตนซ์ ซึ่งช่วยให้ SageMaker สามารถจัดเตรียมชุดการคาดการณ์ที่มีความพร้อมใช้งานสูงใน Availability Zone ต่างๆ สำหรับรุ่นต่างๆ

จากการค้นพบของเรา คุณจะได้รับประสิทธิภาพราคาที่ดีขึ้นในอินสแตนซ์ที่ปรับให้เหมาะสมกับ ML ด้วยแกน GPU ตัวเดียว ดังนั้น การรองรับ MME สำหรับฟีเจอร์ GPU นั้นเปิดใช้งานสำหรับอินสแตนซ์คอร์ GPU เดียวเท่านั้น สำหรับรายการอินสแตนซ์ทั้งหมดที่รองรับ โปรดดูที่ ประเภทอินสแตนซ์ GPU ที่รองรับ.

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=,
    ProductionVariants=[
        {
            "InstanceType": "ml.g4dn.4xlarge",
            "InitialVariantWeight": 1,
            "InitialInstanceCount": 2,
            "ModelName": ,
            "VariantName": "AllTraffic",
        }
    ],
)

สร้างMME

ด้วยการกำหนดค่าปลายทางก่อนหน้านี้ เราจึงสร้าง SageMaker MME โดยใช้ create_endpoint เอพีไอ SageMaker สร้าง MME เรียกใช้อินสแตนซ์การประมวลผล ML g4dn.4xlarge และปรับใช้โมเดล PyTorch และ TensorRT ResNet-50 ดูรหัสต่อไปนี้:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=, EndpointConfigName=
)

เรียกใช้โมเดลเป้าหมายบน MME

หลังจากที่เราสร้างจุดสิ้นสุด เราสามารถส่งคำขออนุมานไปยัง MME โดยใช้คำสั่ง invoke_enpoint เอพีไอ เราระบุ TargetModel ในการเรียกและส่งต่อในส่วนข้อมูลสำหรับรุ่นแต่ละประเภท โค้ดต่อไปนี้เป็นตัวอย่างการเรียกใช้สำหรับโมเดล PyTorch และโมเดล TensorRT:

runtime_sm_client.invoke_endpoint(
    EndpointName=,
    ContentType="application/octet-stream",
    Body=json.dumps(pt_payload),
    TargetModel='resnet_pt_v0.tar.gz', #PyTorch Model
)
runtime_sm_client.invoke_endpoint(
    EndpointName=, 
    ContentType="application/octet-stream", 
    Body=json.dumps(trt_payload),
    TargetModel='resnet_trt_v0.tar.gz' #TensorRT Model
)

ตั้งค่านโยบายการปรับขนาดอัตโนมัติสำหรับ GPU MME

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

ในนโยบายการปรับขนาดต่อไปนี้ เราใช้เมตริกที่กำหนดเอง GPUUtilization ใน TargetTrackingScalingPolicyConfiguration การกำหนดค่าและตั้งค่า a TargetValue of 60.0 สำหรับมูลค่าเป้าหมายของตัวชี้วัดนั้น นโยบายการปรับขนาดอัตโนมัตินี้จัดเตรียมอินสแตนซ์เพิ่มเติมสูงสุด MaxCapacity เมื่อมีการใช้ GPU มากกว่า 60%

auto_scaling_client = boto3.client('application-autoscaling')

resource_id='endpoint/' +  + '/variant/' + 'AllTraffic' 
response = auto_scaling_client.register_scalable_target(
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount',
    MinCapacity=1,
    MaxCapacity=5
)

response = auto_scaling_client.put_scaling_policy(
    PolicyName='GPUUtil-ScalingPolicy',
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount', 
    PolicyType='TargetTrackingScaling',
    TargetTrackingScalingPolicyConfiguration={
        'TargetValue': 60.0, 
        'CustomizedMetricSpecification':
        {
            'MetricName': 'GPUUtilization',
            'Namespace': '/aws/sagemaker/Endpoints',
            'Dimensions': [
                {'Name': 'EndpointName', 'Value':  },
                {'Name': 'VariantName','Value': 'AllTraffic'}
            ],
            'Statistic': 'Average',
            'Unit': 'Percent'
        },
        'ScaleInCooldown': 600,
        'ScaleOutCooldown': 200 
    }
)

เราขอแนะนำให้ใช้ GPUUtilization or InvocationsPerInstance เพื่อกำหนดค่านโยบายการปรับขนาดอัตโนมัติสำหรับ MME ของคุณ ดูรายละเอียดเพิ่มเติมได้ที่ กำหนดนโยบายการปรับขนาดอัตโนมัติสำหรับการปรับใช้ปลายทางหลายรุ่น

ตัววัด CloudWatch สำหรับ GPU MME

SageMaker MME มีตัววัดระดับอินสแตนซ์ต่อไปนี้เพื่อตรวจสอบ:

• โหลด ModelCount – จำนวนรุ่นที่บรรจุในคอนเทนเนอร์
• การใช้งาน GPU – เปอร์เซ็นต์ของหน่วย GPU ที่ใช้โดยคอนเทนเนอร์
• การใช้งานหน่วยความจำ GPU – เปอร์เซ็นต์ของหน่วยความจำ GPU ที่ใช้โดยคอนเทนเนอร์
• การใช้งานดิสก์ – เปอร์เซ็นต์ของพื้นที่ดิสก์ที่ใช้โดยคอนเทนเนอร์

เมตริกเหล่านี้ช่วยให้คุณวางแผนการใช้ทรัพยากรอินสแตนซ์ GPU อย่างมีประสิทธิภาพ ในกราฟต่อไปนี้ เราจะเห็น GPUMemoryUtilization เท่ากับ 38.3% เมื่อโหลด ResNet-16 มากกว่า 50 รุ่นในคอนเทนเนอร์ ผลรวมของการใช้งานคอร์ CPU แต่ละตัว (CPUUtilization) เป็น 60.9% และเปอร์เซ็นต์ของหน่วยความจำที่ใช้โดยคอนเทนเนอร์ (MemoryUtilization) คือ 9.36%

SageMaker MME ยังมีตัววัดการโหลดโมเดลเพื่อรับข้อมูลเชิงลึกระดับการเรียกใช้โมเดล:

• รุ่นกำลังโหลดWaitTime – ช่วงเวลาสำหรับรุ่นที่จะดาวน์โหลดหรือโหลด
• รุ่นUnloadingTime – ช่วงเวลาในการขนถ่ายโมเดลออกจากคอนเทนเนอร์
• โมเดลการดาวน์โหลดเวลา – เวลาในการดาวน์โหลดโมเดลจาก Amazon S3
• รุ่น CacheHit – จำนวนการเรียกใช้ไปยังรุ่นที่โหลดเข้าสู่คอนเทนเนอร์แล้ว

ในกราฟต่อไปนี้ เราสามารถสังเกตได้ว่าโมเดลใช้เวลา 8.22 วินาทีในการตอบสนองต่อคำขออนุมาน (ModelLatency) และ 24.1 มิลลิวินาทีถูกเพิ่มไปยังเวลาแฝงแบบ end-to-end เนื่องจากโอเวอร์เฮดของ SageMaker (OverheadLatency). นอกจากนี้เรายังสามารถดูตัวชี้วัดข้อผิดพลาดจากการเรียกเพื่อเรียกใช้การเรียก API ปลายทางเช่น Invocation4XXErrors และ Invocation5XXErrors.

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับตัววัด MME CloudWatch โปรดดูที่ เมตริก CloudWatch สำหรับการปรับใช้ปลายทางหลายรุ่น.

สรุป

ในโพสต์นี้ คุณได้เรียนรู้เกี่ยวกับการรองรับหลายรุ่นของ SageMaker สำหรับ GPU ซึ่งช่วยให้คุณโฮสต์โมเดลการเรียนรู้เชิงลึกหลายร้อยรายการบนฮาร์ดแวร์ประมวลผลแบบเร่งความเร็วได้อย่างคุ้มค่า คุณได้เรียนรู้วิธีใช้เซิร์ฟเวอร์ NVIDIA Triton Inference ซึ่งสร้างการกำหนดค่าที่เก็บโมเดลสำหรับแบ็กเอนด์เฟรมเวิร์กต่างๆ และวิธีการปรับใช้ MME ด้วยการปรับขนาดอัตโนมัติ ฟีเจอร์นี้จะช่วยให้คุณปรับขนาดโมเดลไฮเปอร์ส่วนบุคคลได้หลายร้อยแบบ ซึ่งปรับแต่งมาอย่างดีเพื่อรองรับประสบการณ์ของผู้ใช้ปลายทางที่ไม่ซ้ำใครในแอปพลิเคชัน AI คุณยังสามารถใช้ประโยชน์จากคุณลักษณะนี้เพื่อให้ได้ประสิทธิภาพราคาที่จำเป็นสำหรับแอปพลิเคชันการอนุมานของคุณโดยใช้ GPU แบบเศษส่วน

ในการเริ่มต้นใช้งานรองรับ MME สำหรับ GPU โปรดดูที่ รองรับปลายทางหลายรุ่นสำหรับ GPU.

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

ดาวัล พาเทล เป็นหัวหน้าสถาปนิก Machine Learning ที่ AWS เขาได้ทำงานร่วมกับองค์กรต่างๆ ตั้งแต่องค์กรขนาดใหญ่ไปจนถึงสตาร์ทอัพขนาดกลางในปัญหาที่เกี่ยวข้องกับการคำนวณแบบกระจายและปัญญาประดิษฐ์ เขามุ่งเน้นไปที่การเรียนรู้อย่างลึกซึ้งรวมถึง NLP และโดเมนวิชันซิสเต็ม เขาช่วยให้ลูกค้าบรรลุการอนุมานแบบจำลองประสิทธิภาพสูงบน Amazon SageMaker

วิกรม เอลังโก เป็นสถาปนิกอาวุโสด้านโซลูชัน AI/ML ที่ Amazon Web Services ซึ่งตั้งอยู่ในเมืองเวอร์จิเนีย สหรัฐอเมริกา Vikram ช่วยลูกค้าในอุตสาหกรรมการเงินและการประกันภัยทั่วโลกด้วยการออกแบบ การใช้งาน และความเป็นผู้นำทางความคิด เพื่อสร้างและปรับใช้แอปพลิเคชันการเรียนรู้ของเครื่องในวงกว้าง ปัจจุบันเขามุ่งเน้นไปที่การประมวลผลภาษาธรรมชาติ AI ที่รับผิดชอบ การเพิ่มประสิทธิภาพการอนุมาน และการปรับสเกล ML ทั่วทั้งองค์กร ในเวลาว่าง เขาสนุกกับการเดินทาง เดินป่า ทำอาหาร และตั้งแคมป์กับครอบครัว

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

ทีปติ ราฆะ เป็นวิศวกรพัฒนาซอฟต์แวร์ในทีม Amazon SageMaker งานปัจจุบันของเธอมุ่งเน้นไปที่การสร้างคุณลักษณะเพื่อโฮสต์โมเดลการเรียนรู้ของเครื่องอย่างมีประสิทธิภาพ ในเวลาว่าง เธอชอบการเดินทาง เดินป่า และปลูกพืช

นิกิล กุลคาร์นิ เป็นนักพัฒนาซอฟต์แวร์ที่มี AWS Machine Learning โดยมุ่งเน้นที่การทำให้เวิร์กโหลดของแมชชีนเลิร์นนิงมีประสิทธิภาพมากขึ้นบนคลาวด์ และเป็นผู้สร้างร่วมของ AWS Deep Learning Containers สำหรับการฝึกอบรมและการอนุมาน เขาหลงใหลเกี่ยวกับการกระจายระบบการเรียนรู้เชิงลึก นอกงาน เขาชอบอ่านหนังสือ เล่นกีตาร์ และทำพิซซ่า

เจียหงหลิว เป็น Solution Architect ในทีม Cloud Service Provider ที่ NVIDIA เขาช่วยลูกค้าในการใช้การเรียนรู้ด้วยเครื่องและโซลูชัน AI ที่ใช้ประโยชน์จากการประมวลผลแบบเร่งความเร็วของ NVIDIA เพื่อจัดการกับความท้าทายในการฝึกอบรมและการอนุมาน ในยามว่าง เขาสนุกกับการพับกระดาษ โปรเจกต์ทำเอง และเล่นบาสเก็ตบอล

เอลิยูธ ไตรอานา เป็น Developer Relations Manager ในทีม NVIDIA-AWS เขาเชื่อมโยงผู้นำผลิตภัณฑ์ Amazon และ AWS นักพัฒนา และนักวิทยาศาสตร์กับนักเทคโนโลยีและผู้นำผลิตภัณฑ์ของ NVIDIA เพื่อเร่งปริมาณงาน Amazon ML/DL, ผลิตภัณฑ์ EC2 และบริการ AWS AI นอกจากนี้ Eliuth ยังเป็นนักขี่จักรยานเสือภูเขา นักเล่นสกี และนักเล่นโป๊กเกอร์ที่หลงใหล

แม็กซิมิเลียโน มักคานติ เป็นวิศวกรหลักที่ AWS ปัจจุบันทำงานกับ DynamoDB ฉันอยู่ในทีมเปิดตัวของ SageMaker ที่ re:Invent 2017 และใช้เวลา 5 ปีต่อจากนั้นในแพลตฟอร์มการโฮสต์โดยเพิ่มคุณสมบัติทุกประเภทที่ลูกค้าต้องเผชิญ ในเวลาว่างของฉัน ฉันสะสม ซ่อมแซม และเล่นกับเครื่องเล่นวิดีโอเกมโบราณ