ปรับใช้ BLOOM-176B และ OPT-30B บน Amazon SageMaker ด้วยการอนุมานโมเดลขนาดใหญ่ Deep Learning Containers และ DeepSpeed

ในช่วงไม่กี่ปีที่ผ่านมามีการพัฒนาอย่างรวดเร็วในด้านการเรียนรู้เชิงลึก แม้ว่าฮาร์ดแวร์จะได้รับการปรับปรุง เช่น ด้วยตัวเร่งรุ่นล่าสุดจาก NVIDIA และ Amazon แต่ผู้ปฏิบัติงานการเรียนรู้ด้วยเครื่องขั้นสูง (ML) ยังคงประสบปัญหาในการปรับใช้โมเดลการเรียนรู้เชิงลึกขนาดใหญ่สำหรับแอปพลิเคชัน เช่น การประมวลผลภาษาธรรมชาติ (NLP) อยู่เป็นประจำ

ในโพสต์ก่อนหน้านี้เราพูดถึง ความสามารถและการตั้งค่าที่กำหนดได้ in การปรับใช้โมเดล Amazon SageMaker ที่สามารถอนุมานด้วยแบบจำลองขนาดใหญ่เหล่านี้ได้ง่ายขึ้น วันนี้ขอประกาศ อเมซอน SageMaker Deep Learning Container (DLC) ที่คุณสามารถใช้เพื่อเริ่มต้นการอนุมานแบบจำลองขนาดใหญ่ได้ในเวลาไม่กี่นาที นี้ DLC รวมไลบรารีโอเพนซอร์สที่ได้รับความนิยมมากที่สุดบางส่วนสำหรับการอนุมานแบบคู่ขนานของโมเดล เช่น DeepSpeed ​​และ Hugging Face Accelerate

ในโพสต์นี้ เราใช้ SageMaker large model inference DLC เพื่อปรับใช้โมเดล NLP ขนาดใหญ่ที่ได้รับความนิยมสูงสุดสองรุ่น: BigScience บลูม-176B และ Meta's OPT-30B จากที่เก็บ Hugging Face โดยเฉพาะอย่างยิ่ง เราใช้การให้บริการ Deep Java Library (DJL) และเทคนิคเทนเซอร์คู่ขนานจาก DeepSpeed ​​เพื่อให้ได้เวลาแฝง 0.1 วินาทีต่อโทเค็นในกรณีการใช้งานการสร้างข้อความ

คุณสามารถค้นหาสมุดบันทึกตัวอย่างที่สมบูรณ์ของเราได้ใน พื้นที่เก็บข้อมูล GitHub.

เทคนิคการอนุมานแบบจำลองขนาดใหญ่

โมเดลภาษาเพิ่งระเบิดทั้งขนาดและความนิยม ด้วยการเข้าถึงที่ง่ายดายจากสวนสัตว์จำลอง เช่น Hugging Face และความแม่นยำและประสิทธิภาพที่ได้รับการปรับปรุงในงาน NLP เช่น การจัดประเภทและการสร้างข้อความ ผู้ปฏิบัติงานจึงเข้าถึงโมเดลขนาดใหญ่เหล่านี้ได้มากขึ้น อย่างไรก็ตาม โมเดลขนาดใหญ่มักจะใหญ่เกินกว่าจะใส่ไว้ในหน่วยความจำของคันเร่งเดียวได้ ตัวอย่างเช่น รุ่น BLOOM-176B ต้องการหน่วยความจำตัวเร่งความเร็วมากกว่า 350 กิกะไบต์ ซึ่งเกินความจุของตัวเร่งฮาร์ดแวร์ที่มีในปัจจุบันมาก สิ่งนี้ทำให้ต้องใช้เทคนิคแบบจำลองขนานของแบบจำลองจากไลบรารีอย่าง DeepSpeed ​​และ Hugging Face Accelerate เพื่อแจกจ่ายแบบจำลองผ่านตัวเร่งหลายตัวสำหรับการอนุมาน ในโพสต์นี้เราใช้ SageMaker คอนเทนเนอร์อนุมานโมเดลขนาดใหญ่ เพื่อสร้างและเปรียบเทียบเวลาแฝงและประสิทธิภาพปริมาณงานโดยใช้ไลบรารีโอเพนซอร์สทั้งสองนี้

DeepSpeed ​​​​และ Accelerate ใช้เทคนิคต่างๆ เพื่อเพิ่มประสิทธิภาพโมเดลภาษาขนาดใหญ่สำหรับการอนุมาน ข้อแตกต่างที่สำคัญคือ DeepSpeed's การใช้เมล็ดที่ปรับให้เหมาะสม. เมล็ดเหล่านี้สามารถปรับปรุงเวลาแฝงของการอนุมานได้อย่างมากโดยการลดคอขวดในกราฟการคำนวณของแบบจำลอง เมล็ดที่ปรับให้เหมาะสมอาจพัฒนาได้ยาก และโดยทั่วไปแล้วจะมีความเฉพาะเจาะจงสำหรับสถาปัตยกรรมแบบจำลองเฉพาะ DeepSpeed ​​รองรับโมเดลขนาดใหญ่ยอดนิยม เช่น OPT และ BLOOM ด้วยเคอร์เนลที่ปรับให้เหมาะสมเหล่านี้ ในทางตรงกันข้าม ไลบรารี Accelerate ของ Hugging Face ไม่ได้รวมเมล็ดที่ปรับให้เหมาะสมในขณะที่เขียน ตามที่เราพูดคุยกันในส่วนผลลัพธ์ ความแตกต่างนี้มีส่วนรับผิดชอบต่อขอบประสิทธิภาพส่วนใหญ่ที่ DeepSpeed ​​มีมากกว่า Accelerate

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

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

ในการโฮสต์โมเดลภาษาขนาดใหญ่อย่างมีประสิทธิภาพ เราต้องการคุณลักษณะและการสนับสนุนในด้านหลักดังต่อไปนี้:

• โซลูชันการสร้างและทดสอบ – ด้วยลักษณะการวนซ้ำของการพัฒนา ML เราจำเป็นต้องมีความสามารถในการสร้าง ทำซ้ำอย่างรวดเร็ว และทดสอบว่าจุดสิ้นสุดการอนุมานจะทำงานอย่างไรเมื่อโฮสต์โมเดลเหล่านี้ รวมถึงความสามารถในการล้มเหลวอย่างรวดเร็ว โดยทั่วไป โมเดลเหล่านี้สามารถโฮสต์ได้เฉพาะในอินสแตนซ์ที่มีขนาดใหญ่กว่า เช่น p4dn หรือ g5 และด้วยขนาดของโมเดล อาจใช้เวลาสักครู่ในการสร้างอินสแตนซ์การอนุมานและเรียกใช้การทดสอบซ้ำ การทดสอบในพื้นที่มักจะมีข้อจำกัด เนื่องจากคุณต้องการอินสแตนซ์ที่มีขนาดใกล้เคียงกันเพื่อทดสอบ และแบบจำลองเหล่านี้ไม่ได้มาโดยง่าย
• การปรับใช้และการทำงานในวงกว้าง – ต้องโหลดไฟล์โมเดลลงในอินสแตนซ์การอนุมาน ซึ่งท้าทายในตัวเองเมื่อพิจารณาจากขนาด Tar / Un-Tar เป็นตัวอย่างสำหรับ Bloom-176B ใช้เวลาประมาณ 1 ชั่วโมงในการสร้างและอีกชั่วโมงในการโหลด เราต้องการกลไกสำรองเพื่อให้เข้าถึงไฟล์โมเดลได้ง่าย
• กำลังโหลดโมเดลเป็นซิงเกิลตัน – สำหรับกระบวนการที่มีผู้ปฏิบัติงานหลายคน เราต้องตรวจสอบให้แน่ใจว่าโมเดลได้รับการโหลดเพียงครั้งเดียว ดังนั้นเราจึงไม่ต้องเผชิญกับสภาวะการแข่งขันและใช้ทรัพยากรที่ไม่จำเป็นเพิ่มเติม ในโพสต์นี้เราจะแสดงวิธีการโหลดโดยตรงจาก บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (อเมซอน เอส3). อย่างไรก็ตาม สิ่งนี้ใช้ได้ก็ต่อเมื่อเราใช้การตั้งค่าเริ่มต้นของ DJL นอกจากนี้ การปรับขนาดจุดปลายใดๆ จะต้องสามารถหมุนได้ภายในไม่กี่นาที ซึ่งต้องมีการพิจารณาใหม่ว่าจะโหลดและแจกจ่ายแบบจำลองอย่างไร
• การแบ่งเฟรมเวิร์ก – โดยทั่วไป โมเดลเหล่านี้ต้องเป็น , โดยปกติโดยกลไกเทนเซอร์คู่ขนานหรือโดยไพพ์ไลน์ชาร์ดเป็นเทคนิคการแบ่งส่วนข้อมูลทั่วไป และเรามีแนวคิดขั้นสูง เช่น การแบ่งส่วน ZeRO ที่สร้างขึ้นบนการแบ่งส่วนเทนเซอร์ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเทคนิคการแบ่งกลุ่ม โปรดดูที่ รุ่น Parallelism. เพื่อให้บรรลุสิ่งนี้ เราสามารถมีการผสมผสานที่หลากหลายและใช้เฟรมเวิร์กจาก NIVIDIA, DeepSpeed ​​และอื่นๆ สิ่งนี้ต้องการความสามารถในการทดสอบ BYOC หรือใช้คอนเทนเนอร์ 1P และวนซ้ำวิธีแก้ปัญหาและเรียกใช้การทดสอบการเปรียบเทียบ คุณอาจต้องการทดสอบตัวเลือกโฮสติ้งต่างๆ เช่น อะซิงโครนัส ไร้เซิร์ฟเวอร์ และอื่นๆ
• การเลือกฮาร์ดแวร์ – การเลือกฮาร์ดแวร์ของคุณจะพิจารณาจากจุดที่กล่าวมาทั้งหมดและรูปแบบการรับส่งข้อมูลเพิ่มเติม ความต้องการของกรณีใช้งาน และขนาดรุ่น

ในโพสต์นี้ เราใช้เคอร์เนลที่ปรับให้เหมาะสมของ DeepSpeed ​​และเทคนิคเทนเซอร์คู่ขนานเพื่อโฮสต์ BLOOM-176B และ OPT-30B บน SageMaker นอกจากนี้เรายังเปรียบเทียบผลลัพธ์จาก Accelerate เพื่อแสดงให้เห็นถึงประโยชน์ด้านประสิทธิภาพของเมล็ดที่ปรับให้เหมาะสมและความขนานของเทนเซอร์ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ DeepSpeed ​​และ Accelerate โปรดดูที่ การอนุมานแบบ DeepSpeed: การเปิดใช้งานการอนุมานที่มีประสิทธิภาพของแบบจำลองหม้อแปลงไฟฟ้าในระดับที่ไม่เคยมีมาก่อน และ การอนุมาน BLOOM ที่รวดเร็วอย่างเหลือเชื่อด้วย DeepSpeed ​​และ Accelerate.

เราใช้ DJLServing เป็นแบบจำลองการให้บริการโซลูชั่นในตัวอย่างนี้ DJLServing เป็นโซลูชันการให้บริการโมเดลสากลที่มีประสิทธิภาพสูงซึ่งขับเคลื่อนโดย Deep Java Library (DJL) ซึ่งเป็นภาษาโปรแกรมที่ไม่เชื่อเรื่องพระเจ้า หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ DJL และ DJLServing โปรดดูที่ ปรับใช้โมเดลขนาดใหญ่บน Amazon SageMaker โดยใช้ DJLServing และการอนุมานแบบขนานของโมเดล DeepSpeed.

เป็นที่น่าสังเกตว่าเมล็ดที่ปรับให้เหมาะสมอาจส่งผลให้เกิดการเปลี่ยนแปลงที่แม่นยำและกราฟการคำนวณที่แก้ไข ซึ่งอาจส่งผลให้พฤติกรรมของแบบจำลองเปลี่ยนไปในทางทฤษฎี แม้ว่าสิ่งนี้อาจเปลี่ยนผลการอนุมานได้เป็นครั้งคราว แต่เราไม่คาดหวังว่าความแตกต่างเหล่านี้จะส่งผลกระทบอย่างมีนัยสำคัญต่อตัวชี้วัดการประเมินพื้นฐานของแบบจำลอง อย่างไรก็ตาม ขอแนะนำให้ผู้ปฏิบัติงานยืนยันว่าผลลัพธ์ของแบบจำลองเป็นไปตามที่คาดไว้เมื่อใช้เมล็ดเหล่านี้

ขั้นตอนต่อไปนี้สาธิตวิธีการปรับใช้โมเดล BLOOM-176B ใน SageMaker โดยใช้ DJLServing และคอนเทนเนอร์อนุมานโมเดลขนาดใหญ่ของ SageMaker ตัวอย่างที่สมบูรณ์ยังมีอยู่ใน .ของเรา พื้นที่เก็บข้อมูล GitHub.

การใช้อิมเมจ DJLServing SageMaker DLC

ใช้รหัสต่อไปนี้เพื่อใช้อิมเมจ 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 ที่มีโค้ดเพียงบรรทัดเดียว สิ่งนี้บอกให้เซิร์ฟเวอร์รุ่น DJL ใช้เอ็นจิ้น DeepSpeed ไฟล์มีรหัสต่อไปนี้:

engine=DeepSpeed

serving.properties เป็นไฟล์ที่กำหนดโดย DJLServing ที่ใช้กำหนดค่าคอนฟิกูเรชันต่อรุ่น

ต่อไปเราจะสร้าง .ของเรา model.py file ซึ่งกำหนดรหัสที่จำเป็นในการโหลดและให้บริการโมเดล ในรหัสของเรา เราอ่านใน TENSOR_PARALLEL_DEGREE ตัวแปรสภาพแวดล้อม (ค่าเริ่มต้นคือ 1) สิ่งนี้กำหนดจำนวนอุปกรณ์ที่กระจายโมดูลเทนเซอร์ขนาน โปรดทราบว่า DeepSpeed ​​ให้คำจำกัดความของพาร์ติชั่นในตัวสองสามตัว รวมถึงคำจำกัดความสำหรับรุ่น BLOOM เราใช้โดยระบุ replace_method และ relpace_with_kernel_inject. หากคุณมีโมเดลที่กำหนดเองและต้องการ DeepSpeed ​​ในการแบ่งพาร์ติชั่นอย่างมีประสิทธิภาพ คุณต้องเปลี่ยน relpace_with_kernel_inject ไปยัง false และเพิ่ม injection_policy เพื่อให้พาร์ติชันรันไทม์ทำงาน สำหรับข้อมูลเพิ่มเติม โปรดดูที่ กำลังเริ่มต้นสำหรับการอนุมาน. ตัวอย่างเช่น เราใช้โมเดล BLOOM ที่แบ่งพาร์ติชั่นล่วงหน้าบน DeepSpeed

ประการที่สอง ใน model.py เรายังโหลดโมเดลจาก Amazon S3 หลังจากหมุนจุดสิ้นสุดแล้ว โมเดลถูกโหลดลงใน /tmp พื้นที่บนคอนเทนเนอร์เนื่องจาก SageMaker จับคู่ /tmp ไป ร้านค้า Amazon Elastic Block (Amazon EBS) ที่ต่อเชื่อมเมื่อเราระบุพารามิเตอร์การสร้างปลายทาง 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 จัดการการติดตั้งรันไทม์บนแพ็คเกจ pip ที่กำหนดไว้ใน 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)

ดาวน์โหลดและจัดเก็บโมเดลจาก Hugging Face (ไม่บังคับ)

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

สร้างโมเดล SageMaker

ตอนนี้เราสร้าง รุ่น SageMaker. เราใช้ การลงทะเบียน Amazon Elastic Container อิมเมจ (Amazon ECR) ที่จัดเตรียมโดยและอาร์ติแฟกต์ของโมเดลจากขั้นตอนก่อนหน้าเพื่อสร้างโมเดล SageMaker ในการตั้งค่าโมเดล เรากำหนดค่า TENSOR_PARALLEL_DEGREE=8ซึ่งหมายความว่าโมเดลถูกแบ่งพาร์ติชันตาม GPU 8 ตัว ดูรหัสต่อไปนี้:

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

หลังจากที่คุณเรียกใช้เซลล์ก่อนหน้าในไฟล์ Jupyter คุณจะเห็นผลลัพธ์ที่คล้ายกับต่อไปนี้:

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

สร้างจุดสิ้นสุด SageMaker

คุณสามารถใช้อินสแตนซ์ใดก็ได้ที่มี GPU หลายตัวสำหรับการทดสอบ ในการสาธิตนี้ เราใช้อินสแตนซ์ p4d.24xlarge ในรหัสต่อไปนี้ สังเกตว่าเราตั้งค่า ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSecondsและ VolumeSizeInGB พารามิเตอร์เพื่อรองรับขนาดโมเดลขนาดใหญ่ ดิ VolumeSizeInGB พารามิเตอร์ใช้ได้กับอินสแตนซ์ GPU ที่รองรับไฟล์แนบวอลุ่ม EBS

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,
        },
    ],
)'

สุดท้ายนี้ เราสร้างจุดสิ้นสุด SageMaker:

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 เพื่อเพิ่มขีดจำกัดในบัญชีของคุณ

การปรับแต่งประสิทธิภาพ

หากคุณต้องการใช้โพสต์นี้และโน้ตบุ๊กที่มาพร้อมกับรุ่นอื่น คุณอาจต้องการสำรวจพารามิเตอร์ที่ปรับแต่งได้ซึ่ง SageMaker, DeepSpeed ​​และ DJL มีให้ การทดลองซ้ำกับพารามิเตอร์เหล่านี้อาจส่งผลกระทบอย่างมีนัยสำคัญต่อเวลาแฝง ปริมาณงาน และต้นทุนของโมเดลขนาดใหญ่ที่โฮสต์ของคุณ หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับพารามิเตอร์การปรับแต่ง เช่น จำนวนคนงาน ระดับของเทนเซอร์คู่ขนาน ขนาดคิวงาน และอื่นๆ โปรดดูที่ การกำหนดค่าการให้บริการ DJL และ ปรับใช้โมเดลขนาดใหญ่บน Amazon SageMaker โดยใช้ DJLServing และการอนุมานแบบขนานของโมเดล DeepSpeed.

ผลสอบ

ในโพสต์นี้ เราใช้ DeepSpeed ​​เพื่อโฮสต์ BLOOM-176B และ OPT-30B บนอินสแตนซ์ SageMaker ML ตารางต่อไปนี้สรุปผลการปฏิบัติงานของเรา รวมถึงการเปรียบเทียบกับการเร่งความเร็วของ Hugging Face เวลาแฝงสะท้อนถึงจำนวนมิลลิวินาทีที่ใช้ในการสร้างสตริงโทเค็น 256 สี่ครั้ง (batch_size=4) จากรุ่น ปริมาณงานแสดงจำนวนโทเค็นที่ผลิตต่อวินาทีสำหรับการทดสอบแต่ละครั้ง สำหรับ Hugging Face Accelerate เราใช้การโหลดเริ่มต้นของไลบรารีที่มีการแมปหน่วยความจำ GPU สำหรับ DeepSpeed ​​เราใช้กลไกการโหลดจุดตรวจที่เร็วขึ้น

จากมุมมองของเวลาแฝง DeepSpeed ​​เร็วขึ้นประมาณ 3.4 เท่าสำหรับ BLOOM-176B และเร็วกว่า 5.6 เท่าสำหรับ OPT-30B เมื่อเทียบกับ Accelerate เคอร์เนลที่ได้รับการปรับแต่งของ DeepSpeed ​​มีส่วนรับผิดชอบต่อความแตกต่างของเวลาแฝง จากผลลัพธ์เหล่านี้ เราขอแนะนำให้ใช้ DeepSpeed ​​แทน Accelerate หากรุ่นที่คุณเลือกได้รับการสนับสนุน

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

ผลลัพธ์เหล่านี้ยังแสดงให้เห็นความแตกต่างของเวลาแฝงและปริมาณงานของขนาดโมเดลต่างๆ ในการทดสอบของเรา OPT-30B สร้างจำนวนโทเค็นต่อหน่วยเวลา 2.4 เท่าซึ่งมากกว่า BLOOM-176B ในประเภทอินสแตนซ์ที่มีราคาถูกกว่ามากกว่าสามเท่า ตามราคาต่อหน่วยปริมาณงาน OPT-30B บนอินสแตนซ์ g5.24xl นั้นดีกว่า BLOOM-8.9B 176 เท่าบนอินสแตนซ์ p4d.24xl หากคุณมีเวลาแฝง ปริมาณงาน หรือข้อจำกัดด้านต้นทุนที่เข้มงวด ให้ลองใช้แบบจำลองที่เล็กที่สุดเท่าที่จะเป็นไปได้ซึ่งยังคงบรรลุข้อกำหนดด้านการทำงาน

ทำความสะอาด

ตามแนวทางปฏิบัติที่ดีที่สุด ขอแนะนำให้ลบอินสแตนซ์ที่ไม่ได้ใช้งานเสมอ รหัสด้านล่างแสดงวิธีการลบอินสแตนซ์

# - 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}

สรุป

ในโพสต์นี้ เราสาธิตวิธีใช้คอนเทนเนอร์อนุมานแบบจำลองขนาดใหญ่ของ SageMaker เพื่อโฮสต์โมเดลภาษาขนาดใหญ่สองรุ่น ได้แก่ BLOOM-176B และ OPT-30B เราใช้เทคนิคแบบจำลองขนานของ DeepSpeed ​​กับ GPU หลายตัวในอินสแตนซ์ SageMaker ML เดียว

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับ Amazon SageMaker และความสามารถในการอนุมานโมเดลขนาดใหญ่ โปรดดูที่ ตอนนี้ Amazon SageMaker รองรับการปรับใช้โมเดลขนาดใหญ่ผ่านขนาดไดรฟ์ข้อมูลที่กำหนดค่าได้และโควตาการหมดเวลา และ การอนุมานตามเวลาจริง.

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

ไซม่อน ซามาริน เป็นสถาปนิกโซลูชัน AI/ML ซึ่งมุ่งเน้นหลักในการช่วยลูกค้าดึงคุณค่าจากสินทรัพย์ข้อมูลของตน ในเวลาว่าง Simon สนุกกับการใช้เวลาอยู่กับครอบครัว อ่านนิยายวิทยาศาสตร์ และทำงานในโครงการบ้าน DIY ต่างๆ

รูพินเดอร์ กรีวาล เป็น Sr Ai/ML Specialist Solutions Architect กับ AWS ปัจจุบันเขามุ่งเน้นการให้บริการโมเดลและ MLOps บน SageMaker ก่อนหน้าจะรับตำแหน่งนี้ เขาเคยทำงานเป็นวิศวกรด้านการเรียนรู้ของเครื่องจักรในการสร้างและโฮสต์โมเดล นอกเวลางาน เขาชอบเล่นเทนนิสและขี่จักรยานบนเส้นทางบนภูเขา

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

อลัน ตัน เป็นผู้จัดการผลิตภัณฑ์อาวุโสที่มี SageMaker เป็นผู้นำในการอนุมานแบบจำลองขนาดใหญ่ เขาหลงใหลในการใช้แมชชีนเลิร์นนิงในด้านการวิเคราะห์ นอกเวลางาน เขาสนุกกับกิจกรรมกลางแจ้ง

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

ชิงหลาน เป็นวิศวกรพัฒนาซอฟต์แวร์ใน AWS เขาทำงานเกี่ยวกับผลิตภัณฑ์ที่ท้าทายหลายอย่างใน Amazon รวมถึงโซลูชันการอนุมาน ML ประสิทธิภาพสูงและระบบการบันทึกที่มีประสิทธิภาพสูง ทีมของ Qing ประสบความสำเร็จในการเปิดตัวโมเดลพารามิเตอร์พันล้านรายการแรกใน Amazon Advertising โดยต้องมีเวลาแฝงที่ต่ำมาก Qing มีความรู้เชิงลึกเกี่ยวกับการเพิ่มประสิทธิภาพโครงสร้างพื้นฐานและการเร่งการเรียนรู้เชิงลึก

ชิงเหว่ย ลี่ เป็นผู้เชี่ยวชาญด้าน Machine Learning ที่ Amazon Web Services เขาได้รับปริญญาเอกของเขา ใน Operations Research หลังจากที่เขาทำลายบัญชีทุนวิจัยของที่ปรึกษาและล้มเหลวในการมอบรางวัลโนเบลที่เขาสัญญาไว้ ปัจจุบันเขาช่วยลูกค้าในอุตสาหกรรมบริการทางการเงินและประกันภัยสร้างโซลูชันแมชชีนเลิร์นนิงบน AWS เวลาว่างชอบอ่านหนังสือและสอน

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

สิทธัตถะ เวนกาเตสัน เป็นวิศวกรซอฟต์แวร์ใน AWS Deep Learning ปัจจุบันเขามุ่งเน้นไปที่การสร้างโซลูชันสำหรับการอนุมานแบบจำลองขนาดใหญ่ ก่อนหน้าที่ AWS เขาทำงานในองค์กร Amazon Grocery ในการสร้างคุณสมบัติการชำระเงินใหม่สำหรับลูกค้าทั่วโลก นอกงาน เขาชอบเล่นสกี กลางแจ้ง และดูกีฬา