เพิ่มประสิทธิภาพการแพร่กระจายที่เสถียรสูงสุดและลดต้นทุนการอนุมานด้วย AWS Inferentia2 | บริการเว็บอเมซอน

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

ในโพสต์นี้ เราจะแสดงวิธีเรียกใช้โมเดล Stable Diffusion และบรรลุประสิทธิภาพสูงด้วยต้นทุนที่ต่ำที่สุดใน อเมซอน อีลาสติก คอมพิวท์ คลาวด์ (อเมซอน EC2) โดยใช้ อินสแตนซ์ Amazon EC2 Inf2 ขับเคลื่อนด้วย AWS Inferentia2. เราดูที่สถาปัตยกรรมของแบบจำลอง Stable Diffusion และอธิบายขั้นตอนของการรวบรวมแบบจำลอง Stable Diffusion โดยใช้ AWS เซลล์ประสาท และปรับใช้กับอินสแตนซ์ Inf2 นอกจากนี้ เรายังหารือเกี่ยวกับการเพิ่มประสิทธิภาพที่ Neuron SDK สร้างขึ้นโดยอัตโนมัติเพื่อปรับปรุงประสิทธิภาพ คุณสามารถเรียกใช้ทั้งเวอร์ชัน Stable Diffusion 2.1 และ 1.5 บน AWS Inferentia2 ได้อย่างคุ้มค่า สุดท้าย เราจะแสดงวิธีการปรับใช้โมเดล Stable Diffusion กับอินสแตนซ์ Inf2 ด้วย อเมซอน SageMaker.

ขนาดโมเดล Stable Diffusion 2.1 ในทศนิยม 32 (FP32) คือ 5 GB และ 2.5 GB ใน bfoat16 (BF16) อินสแตนซ์ inf2.xlarge เดียวมีตัวเร่งความเร็ว AWS Inferentia2 หนึ่งตัวพร้อมหน่วยความจำ HBM ขนาด 32 GB โมเดล Stable Diffusion 2.1 สามารถใส่ได้กับอินสแตนซ์ inf2.xlarge เดียว Stable Diffusion เป็นโมเดลแปลงข้อความเป็นรูปภาพที่คุณสามารถใช้สร้างรูปภาพที่มีสไตล์และเนื้อหาต่างๆ ได้ง่ายๆ โดยป้อนข้อความเป็นข้อความแจ้ง หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสถาปัตยกรรมแบบจำลอง Stable Diffusion โปรดดูที่ สร้างอิมเมจคุณภาพสูงด้วยโมเดล Stable Diffusion และปรับใช้อย่างคุ้มค่าด้วย Amazon SageMaker.

วิธีที่ Neuron SDK เพิ่มประสิทธิภาพการกระจายที่เสถียร

ก่อนที่เราจะปรับใช้โมเดล Stable Diffusion 2.1 บนอินสแตนซ์ AWS Inferentia2 เราจำเป็นต้องรวบรวมส่วนประกอบโมเดลโดยใช้ เซลล์ประสาท SDK. Neuron SDK ซึ่งประกอบด้วยคอมไพเลอร์การเรียนรู้เชิงลึก รันไทม์ และเครื่องมือ คอมไพล์และปรับโมเดลการเรียนรู้เชิงลึกให้เหมาะสมโดยอัตโนมัติ เพื่อให้พวกเขาสามารถทำงานได้อย่างมีประสิทธิภาพบนอินสแตนซ์ Inf2 และดึงประสิทธิภาพเต็มรูปแบบของตัวเร่งความเร็ว AWS Inferentia2 เรามีตัวอย่างสำหรับรุ่น Stable Diffusion 2.1 บน repo GitHub. สมุดบันทึกนี้นำเสนอตัวอย่างแบบ end-to-end ของวิธีการคอมไพล์โมเดล Stable Diffusion บันทึกโมเดล Neuron ที่คอมไพล์แล้ว และโหลดลงในรันไทม์เพื่อการอนุมาน

เราใช้ StableDiffusionPipeline จากหน้ากอด diffusers ไลบรารีเพื่อโหลดและคอมไพล์โมเดล จากนั้นเราจะรวบรวมส่วนประกอบทั้งหมดของโมเดลสำหรับ Neuron ที่ใช้ torch_neuronx.trace() และบันทึกโมเดลที่ปรับให้เหมาะสมเป็น TorchScript กระบวนการคอมไพล์อาจใช้หน่วยความจำค่อนข้างมาก ทำให้ต้องใช้ RAM จำนวนมาก เพื่อหลีกเลี่ยงปัญหานี้ ก่อนที่จะติดตามแต่ละโมเดล เราจะสร้าง deepcopy ของส่วนของท่อที่กำลังติดตาม ต่อไปนี้ เราจะลบวัตถุไปป์ไลน์ออกจากหน่วยความจำโดยใช้ del pipe. เทคนิคนี้มีประโยชน์อย่างยิ่งเมื่อคอมไพล์ในอินสแตนซ์ที่มี RAM ต่ำ

นอกจากนี้ เรายังดำเนินการปรับแต่งโมเดลการแพร่กระจายที่เสถียรอีกด้วย UNet ให้ความสำคัญกับการอนุมานอย่างเข้มข้นที่สุด คอมโพเนนต์ UNet ทำงานบนอินพุตเทนเซอร์ที่มีขนาดแบทช์ XNUMX ตัว โดยสร้างเทนเซอร์เอาต์พุตที่สอดคล้องกันด้วยขนาดแบทช์ XNUMX ตัว เพื่อสร้างอิมเมจเดียว องค์ประกอบภายในแบทช์เหล่านี้เป็นอิสระจากกันโดยสิ้นเชิง เราสามารถใช้ประโยชน์จากลักษณะการทำงานนี้เพื่อให้ได้เวลาแฝงที่เหมาะสมโดยเรียกใช้ชุดหนึ่งชุดใน Neuron core แต่ละตัว เรารวบรวม UNet สำหรับชุดเดียว (โดยใช้อินพุตเทนเซอร์กับชุดเดียว) จากนั้นใช้ torch_neuronx.DataParallel API เพื่อโหลดโมเดลแบทช์เดียวนี้ลงในแต่ละคอร์ เอาต์พุตของ API นี้เป็นโมดูลแบบสองแบทช์ที่ราบรื่น: เราสามารถส่งผ่านอินพุตของสองแบทช์ไปยัง UNet และส่งคืนเอาต์พุตแบบสองแบทช์ แต่ภายใน โมเดลแบบแบทช์เดียวสองแบบกำลังทำงานบนแกนประสาทสองแกน . กลยุทธ์นี้เพิ่มประสิทธิภาพการใช้ทรัพยากรและลดเวลาแฝง

คอมไพล์และปรับใช้โมเดลการแพร่กระจายที่เสถียรบนอินสแตนซ์ Inf2 EC2

ในการคอมไพล์และปรับใช้โมเดล Stable Diffusion บนอินสแตนซ์ Inf2 EC2 ให้ลงชื่อเข้าใช้ คอนโซลการจัดการ AWS และสร้างอินสแตนซ์ inf2.8xlarge โปรดทราบว่าอินสแตนซ์ inf2.8xlarge จำเป็นสำหรับการคอมไพล์โมเดลเท่านั้น เนื่องจากการคอมไพล์ต้องใช้หน่วยความจำโฮสต์ที่สูงกว่า โมเดล Stable Diffusion สามารถโฮสต์บนอินสแตนซ์ inf2.xlarge คุณสามารถค้นหา AMI ล่าสุดที่มีไลบรารี Neuron โดยใช้ข้อมูลต่อไปนี้ อินเทอร์เฟซบรรทัดคำสั่ง AWS AWS (AWS CLI) คำสั่ง:

aws ec2 describe-images --region us-east-1 --owners amazon --filters 'Name=name,Values=Deep Learning AMI Neuron PyTorch 1.13.? (Amazon Linux 2) ????????' 'Name=state,Values=available' --query 'reverse(sort_by(Images, &CreationDate))[:1].ImageId' --output text

สำหรับตัวอย่างนี้ เราสร้างอินสแตนซ์ EC2 โดยใช้ Deep Learning AMI Neuron PyTorch 1.13 (Ubuntu 20.04) จากนั้น คุณสามารถสร้างสภาพแวดล้อมห้องปฏิบัติการ JupyterLab โดยเชื่อมต่อกับอินสแตนซ์และดำเนินการตามขั้นตอนต่อไปนี้:

run source /opt/aws_neuron_venv_pytorch/bin/activate
pip install jupyterlab
jupyter-lab

โน้ตบุ๊กที่มีขั้นตอนทั้งหมดสำหรับการคอมไพล์และโฮสต์โมเดลอยู่บนนั้น GitHub.

มาดูขั้นตอนการคอมไพล์สำหรับบล็อกตัวเข้ารหัสข้อความตัวใดตัวหนึ่ง บล็อกอื่นๆ ที่เป็นส่วนหนึ่งของไปป์ไลน์ Stable Diffusion สามารถคอมไพล์ได้เช่นเดียวกัน

ขั้นตอนแรกคือการโหลดโมเดลที่ฝึกไว้ล่วงหน้าจาก Hugging Face เดอะ StableDiffusionPipeline.from_pretrained เมธอดจะโหลดโมเดลที่ฝึกไว้ล่วงหน้าลงในออบเจกต์ไปป์ไลน์ของเรา pipe. จากนั้นเราก็สร้าง deepcopy ของตัวเข้ารหัสข้อความจากไปป์ไลน์ของเรา โคลนมันได้อย่างมีประสิทธิภาพ เดอะ del pipe จากนั้นใช้คำสั่งเพื่อลบออบเจกต์ไปป์ไลน์ดั้งเดิม เพิ่มหน่วยความจำที่ถูกใช้ไป ที่นี่ เรากำลังวัดปริมาณแบบจำลองเป็นน้ำหนัก BF16:

model_id = "stabilityai/stable-diffusion-2-1-base"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
text_encoder = copy.deepcopy(pipe.text_encoder)
del pipe

ขั้นตอนนี้เกี่ยวข้องกับการห่อตัวเข้ารหัสข้อความของเราด้วย NeuronTextEncoder กระดาษห่อ ผลลัพธ์ของโมดูลตัวเข้ารหัสข้อความที่คอมไพล์แล้วจะเป็นของ dict. เราแปลงเป็น list พิมพ์โดยใช้กระดาษห่อนี้:

text_encoder = NeuronTextEncoder(text_encoder)

เราเริ่มต้นเทนเซอร์ PyTorch emb ด้วยค่าบางอย่าง เดอะ emb เทนเซอร์ใช้เป็นอินพุตตัวอย่างสำหรับ torch_neuronx.trace การทำงาน. ฟังก์ชันนี้ติดตามตัวเข้ารหัสข้อความของเราและคอมไพล์เป็นรูปแบบที่ปรับให้เหมาะกับ Neuron เส้นทางไดเร็กทอรีสำหรับโมเดลที่คอมไพล์ถูกสร้างขึ้นโดยการรวม COMPILER_WORKDIR_ROOT ด้วยไดเร็กทอรีย่อย text_encoder:

emb = torch.tensor([...])
text_encoder_neuron = torch_neuronx.trace(
        text_encoder.neuron_text_encoder,
        emb,
        compiler_workdir=os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder'),
        )

ตัวเข้ารหัสข้อความที่คอมไพล์แล้วจะถูกบันทึกโดยใช้ torch.jit.save. มันถูกเก็บไว้ภายใต้ชื่อไฟล์ model.pt ใน text_encoder ไดเร็กทอรีของพื้นที่ทำงานของคอมไพเลอร์ของเรา:

text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder/model.pt')
torch.jit.save(text_encoder_neuron, text_encoder_filename)

พื้นที่ สมุดบันทึก มีขั้นตอนที่คล้ายกันในการรวบรวมส่วนประกอบอื่นๆ ของโมเดล: UNet, ตัวถอดรหัส VAE และ VAE post_quant_conv. หลังจากที่คุณรวบรวมโมเดลทั้งหมดแล้ว คุณสามารถโหลดและรันโมเดลได้โดยทำตามขั้นตอนเหล่านี้:

1. กำหนดเส้นทางสำหรับโมเดลที่คอมไพล์แล้ว
2. โหลดการฝึกอบรมล่วงหน้า StableDiffusionPipeline รุ่นที่มีการระบุการกำหนดค่าให้ใช้ชนิดข้อมูล bfloat16
3. โหลดโมเดล UNet ลงบน Neuron core สองคอร์โดยใช้ torch_neuronx.DataParallel เอพีไอ สิ่งนี้ทำให้สามารถดำเนินการอนุมานแบบคู่ขนานของข้อมูลได้ ซึ่งสามารถเพิ่มความเร็วให้กับประสิทธิภาพของแบบจำลองได้อย่างมาก
4. โหลดส่วนที่เหลือของโมเดล (text_encoder, decoderและ post_quant_conv) ลงบนแกนกลางเซลล์เดียว

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

• ภาพเหมือนของ renaud sechan, ปากกาและหมึก, ภาพวาดลายเส้นที่สลับซับซ้อน โดย เครก มัลลินส์, หรวนเจีย, เคนทาโร มิอุระ, เกร็ก รุตโคว์สกี้, เลาน์ดรอว์

• ภาพคนขุดถ่านหินเก่าในศตวรรษที่ 19 ภาพวาดสวยงามพร้อมภาพวาดใบหน้าที่มีรายละเอียดสูงโดย greg rutkowski

• ปราสาทกลางป่า

โฮสต์ Stable Diffusion 2.1 บน AWS Inferentia2 และ SageMaker

การโฮสต์โมเดล Stable Diffusion ด้วย SageMaker ยังต้องมีการคอมไพล์ด้วย Neuron SDK คุณสามารถคอมไพล์ให้เสร็จก่อนเวลาหรือระหว่างรันไทม์ได้โดยใช้คอนเทนเนอร์ Large Model Inference (LMI) การคอมไพล์ล่วงหน้าช่วยให้โหลดโมเดลได้เร็วขึ้นและเป็นตัวเลือกที่ต้องการ

คอนเทนเนอร์ SageMaker LMI มีสองวิธีในการปรับใช้โมเดล:

• ตัวเลือกแบบไม่มีรหัสที่เราให้ไว้ serving.properties ไฟล์ที่มีการกำหนดค่าที่จำเป็น
• นำสคริปต์การอนุมานของคุณเอง

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

กำหนดค่าโมเดลด้วยสคริปต์ที่ให้มา

ในส่วนนี้ เราจะแสดงวิธีกำหนดค่าคอนเทนเนอร์ LMI เพื่อโฮสต์โมเดล Stable Diffusion โน้ตบุ๊ก SD2.1 พร้อมใช้งานบน GitHub ขั้นตอนแรกคือการสร้างแพ็คเกจการกำหนดค่าโมเดลตามโครงสร้างไดเร็กทอรีต่อไปนี้ เป้าหมายของเราคือใช้การกำหนดค่าโมเดลขั้นต่ำที่จำเป็นในการโฮสต์โมเดล โครงสร้างไดเร็กทอรีที่จำเป็นมีดังนี้:

<config-root-directory> / 
    ├── serving.properties
    │   
    └── model.py [OPTIONAL]

ต่อไปเราจะสร้าง ให้บริการคุณสมบัติ ไฟล์ที่มีพารามิเตอร์ต่อไปนี้:

%%writefile code_sd/serving.properties
engine=Python
option.entryPoint=djl_python.transformers-neuronx
option.use_stable_diffusion=True
option.model_id=s3url
option.tensor_parallel_degree=2
option.dtype=bf16

พารามิเตอร์ระบุต่อไปนี้:

• ตัวเลือก model_id – คอนเทนเนอร์ LMI ใช้ s5cmd เพื่อโหลดโมเดลจากตำแหน่ง S3 ดังนั้นเราจึงจำเป็นต้องระบุตำแหน่งของน้ำหนักที่รวบรวมของเรา
• option.จุดเข้า – ในการใช้ตัวจัดการในตัว เราระบุคลาสของ Transformers-neuronx หากคุณมีสคริปต์การอนุมานที่กำหนดเอง คุณต้องระบุสคริปต์นั้นแทน
• ตัวเลือก.dtype – ระบุให้โหลดน้ำหนักในขนาดที่กำหนด สำหรับโพสต์นี้ เราใช้ BF16 ซึ่งช่วยลดความต้องการหน่วยความจำของเราเมื่อเทียบกับ FP32 และลดเวลาแฝงลงเนื่องจากเหตุผลดังกล่าว
• option.tensor_parallel_degree – พารามิเตอร์นี้ระบุจำนวนตัวเร่งที่เราใช้สำหรับรุ่นนี้ AWS Inferentia2 Chip Accelerator มี Neuron 2 คอร์ ดังนั้นการระบุค่า XNUMX หมายความว่าเราใช้ Accelerator หนึ่งตัว (สองคอร์) ซึ่งหมายความว่าตอนนี้เราสามารถสร้างพนักงานหลายคนเพื่อเพิ่มปริมาณงานของเครื่องปลายทาง
• ตัวเลือกเครื่องยนต์ – สิ่งนี้ถูกตั้งค่าเป็น Python เพื่อระบุว่าเราจะไม่ใช้คอมไพเลอร์อื่นเช่น DeepSpeed ​​หรือ Faster Transformer สำหรับโฮสติ้งนี้

นำสคริปต์ของคุณเอง

หากคุณต้องการนำสคริปต์การอนุมานที่คุณกำหนดเอง คุณต้องลบ option.entryPoint ราคาเริ่มต้นที่ serving.properties. คอนเทนเนอร์ LMI ในกรณีนั้นจะค้นหา model.py ไฟล์ในตำแหน่งเดียวกับไฟล์ serving.properties และใช้สิ่งนั้นเพื่อเรียกใช้การอนุมาน

สร้างสคริปต์การอนุมานของคุณเอง (model.py)

การสร้างสคริปต์การอนุมานของคุณเองนั้นค่อนข้างตรงไปตรงมาโดยใช้คอนเทนเนอร์ LMI คอนเทนเนอร์ต้องการของคุณ model.py ไฟล์เพื่อให้มีการดำเนินการตามวิธีการต่อไปนี้:

def handle(inputs: Input) which returns an object of type Outputs

ลองตรวจสอบบางส่วนของพื้นที่ที่สำคัญของ โน๊ตบุ๊คที่แนบมาซึ่งสาธิตการนำฟังก์ชันสคริปต์มาเอง

แทนที่ cross_attention โมดูลที่มีเวอร์ชันที่ปรับให้เหมาะสม:

# Replace original cross-attention module with custom cross-attention module for better performance
    CrossAttention.get_attention_scores = get_attention_scores
Load the compiled weights for the following
text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder.pt')
decoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'vae_decoder.pt')
unet_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'unet.pt')
post_quant_conv_filename =. os.path.join(COMPILER_WORKDIR_ROOT, 'vae_post_quant_conv.pt')

นี่คือชื่อของไฟล์น้ำหนักที่คอมไพล์แล้วที่เราใช้เมื่อสร้างการคอมไพล์ อย่าลังเลที่จะเปลี่ยนชื่อไฟล์ แต่ให้แน่ใจว่าชื่อไฟล์ Weights ของคุณตรงกับที่คุณระบุที่นี่

จากนั้นเราจำเป็นต้องโหลดโดยใช้ Neuron SDK และตั้งค่าเหล่านี้เป็นน้ำหนักแบบจำลองจริง เมื่อโหลดตุ้มน้ำหนักที่ปรับให้เหมาะสมของ UNet โปรดทราบว่าเรากำลังระบุจำนวนของแกน Neuron ที่เราต้องโหลดลงไปด้วย ที่นี่ เราโหลดไปยังตัวเร่งความเร็วเดียวที่มีสองคอร์:

# Load the compiled UNet onto two neuron cores.
    pipe.unet = NeuronUNet(UNetWrap(pipe.unet))
    logging.info(f"Loading model: unet:created")
    device_ids = [idx for idx in range(tensor_parallel_degree)]
   
    pipe.unet.unetwrap = torch_neuronx.DataParallel(torch.jit.load(unet_filename), device_ids, set_dynamic_batching=False)
   
 
    # Load other compiled models onto a single neuron core.
 
    # - load encoders
    pipe.text_encoder = NeuronTextEncoder(pipe.text_encoder)
    clip_compiled = torch.jit.load(text_encoder_filename)
    pipe.text_encoder.neuron_text_encoder = clip_compiled
    #- load decoders
    pipe.vae.decoder = torch.jit.load(decoder_filename)
    pipe.vae.post_quant_conv = torch.jit.load(post_quant_conv_filename)

การรันการอนุมานด้วยพรอมต์จะเรียกวัตถุไปป์เพื่อสร้างอิมเมจ

สร้างปลายทาง SageMaker

เราใช้ Boto3 API เพื่อสร้างปลายทาง SageMaker ทำตามขั้นตอนต่อไปนี้:

1. สร้าง tarball ด้วยการเสิร์ฟและทางเลือก model.py ไฟล์และอัปโหลดไปยัง Amazon S3
2. สร้างโมเดลโดยใช้ที่เก็บรูปภาพและโมเดล tarball ที่อัปโหลดก่อนหน้านี้
3. สร้างการกำหนดค่าปลายทางโดยใช้พารามิเตอร์หลักต่อไปนี้:
   1. ใช้ ml.inf2.xlarge ตัวอย่าง.
   2. ชุด ContainerStartupHealthCheckTimeoutInSeconds ถึง 240 เพื่อให้แน่ใจว่าการตรวจสุขภาพเริ่มต้นหลังจากปรับใช้โมเดล
   3. ชุด VolumeInGB เป็นค่าที่มากขึ้น จึงสามารถใช้สำหรับโหลดน้ำหนักโมเดลที่มีขนาด 32 GB

สร้างโมเดล SageMaker

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

inference_image_uri = (
    f"763104351884.dkr.ecr.{region}.amazonaws.com/djl-inference:0 djl-serving-inf2"
)

สร้างโมเดลออบเจกต์ ซึ่งโดยพื้นฐานแล้วจะสร้างคอนเทนเนอร์ล็อกดาวน์ที่โหลดลงในอินสแตนซ์และใช้สำหรับอนุมาน:

model_name = name_from_base(f"inf2-sd")
create_model_response = boto3_sm_client.create_model(
    ModelName=model_name,
    ExecutionRoleArn=role,
    PrimaryContainer={"Image": inference_image_uri, "ModelDataUrl": s3_code_artifact},
)

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

ในการสาธิตนี้ เราใช้อินสแตนซ์ ml.inf2.xlarge เราต้องตั้งค่า VolumeSizeInGB พารามิเตอร์เพื่อให้พื้นที่ดิสก์ที่จำเป็นในการโหลดโมเดลและน้ำหนัก พารามิเตอร์นี้ใช้ได้กับอินสแตนซ์ที่สนับสนุน ร้านค้า Amazon Elastic Block ไฟล์แนบปริมาณ (Amazon EBS) เราสามารถปล่อยให้ระยะหมดเวลาการดาวน์โหลดโมเดลและการตรวจสอบความสมบูรณ์ของการเริ่มต้นคอนเทนเนอร์เป็นค่าที่สูงขึ้น ซึ่งจะทำให้คอนเทนเนอร์มีเวลาเพียงพอในการดึงน้ำหนักจาก Amazon S3 และโหลดลงใน AWS Inferentia2 accelerators สำหรับรายละเอียดเพิ่มเติม โปรดดูที่ สร้าง EndpointConfig.

endpoint_config_response = boto3_sm_client.create_endpoint_config( EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.inf2.xlarge", # - 
            "InitialInstanceCount": 1,
            "ContainerStartupHealthCheckTimeoutInSeconds": 360, 
            "VolumeSizeInGB": 400
        },
    ],
)

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

create_endpoint_response = boto3_sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

เรียกใช้จุดสิ้นสุดของโมเดล

นี่เป็นแบบจำลองเชิงกำเนิด ดังนั้นเราจึงส่งพร้อมท์ที่แบบจำลองใช้เพื่อสร้างภาพ เพย์โหลดเป็นประเภท JSON:

response_model = boto3_sm_run_client.invoke_endpoint( EndpointName=endpoint_name,
    Body=json.dumps(
        {
            "prompt": "Mountain Landscape", 
            "parameters": {} # 
        }
    ), 
    ContentType="application/json",
)

การเปรียบเทียบแบบจำลองการแพร่กระจายที่เสถียรบน Inf2

เราทำการทดสอบสองสามอย่างเพื่อเปรียบเทียบแบบจำลอง Stable Diffusion กับประเภทข้อมูล BF 16 บน Inf2 และเราสามารถหาตัวเลขเวลาแฝงที่เทียบเคียงหรือสูงกว่าตัวเร่งความเร็วอื่นๆ บางตัวสำหรับ Stable Diffusion เมื่อรวมกับต้นทุนที่ต่ำกว่าของชิป AWS Inferentia2 ทำให้ข้อเสนอนี้มีค่าอย่างยิ่ง

ตัวเลขต่อไปนี้มาจากโมเดล Stable Diffusion ที่ปรับใช้บนอินสแตนซ์ inf2.xl สำหรับข้อมูลเพิ่มเติมเกี่ยวกับค่าใช้จ่าย โปรดดูที่ อินสแตนซ์ Amazon EC2 Inf2.

สรุป

ในโพสต์นี้ เราจะลงลึกในการรวบรวม การเพิ่มประสิทธิภาพ และการปรับใช้โมเดล Stable Diffusion 2.1 โดยใช้อินสแตนซ์ Inf2 เรายังสาธิตการปรับใช้โมเดลการแพร่กระจายที่เสถียรโดยใช้ SageMaker อินสแตนซ์ Inf2 ยังมอบประสิทธิภาพด้านราคาที่ยอดเยี่ยมสำหรับ Stable Diffusion 1.5 หากต้องการเรียนรู้เพิ่มเติมว่าเหตุใดอินสแตนซ์ Inf2 จึงยอดเยี่ยมสำหรับ AI เชิงกำเนิดและโมเดลภาษาขนาดใหญ่ โปรดดูที่ อินสแตนซ์ Amazon EC2 Inf2 สำหรับการอนุมาน AI แบบสร้างต้นทุนต่ำและประสิทธิภาพสูงพร้อมให้ใช้งานโดยทั่วไปแล้ว. สำหรับรายละเอียดประสิทธิภาพ โปรดดูที่ ประสิทธิภาพของ Inf2. ดูตัวอย่างเพิ่มเติมได้ที่ repo GitHub.

ขอขอบคุณเป็นพิเศษสำหรับ Matthew Mcclain, Beni Hegedus, Kamran Khan, Shruti Koparkar และ Qing Lan สำหรับการตรวจสอบและให้ข้อมูลที่มีค่า

เกี่ยวกับผู้เขียน

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

เคซี ตุ้ง เป็นสถาปนิกโซลูชันอาวุโสใน AWS Annapurna Labs เขาเชี่ยวชาญในการฝึกอบรมโมเดลการเรียนรู้เชิงลึกขนาดใหญ่และการปรับใช้ในระดับบนคลาวด์ เขามีปริญญาเอก สาขาชีวฟิสิกส์ระดับโมเลกุล จาก University of Texas Southwestern Medical Center ในดัลลัส เขาได้พูดที่ AWS Summits และ AWS Reinvent วันนี้เขาช่วยลูกค้าในการฝึกอบรมและปรับใช้โมเดล PyTorch และ TensorFlow ขนาดใหญ่ใน AWS Cloud เขาเป็นผู้แต่งหนังสือสองเล่ม: เรียนรู้ TensorFlow Enterprise และ การอ้างอิงพ็อกเก็ต TensorFlow 2.

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

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• PlatoData.Network Vertical Generative Ai เพิ่มพลังให้กับตัวเอง เข้าถึงได้ที่นี่.
• เพลโตไอสตรีม. Web3 อัจฉริยะ ขยายความรู้ เข้าถึงได้ที่นี่.
• เพลโตESG. ยานยนต์ / EVs, คาร์บอน, คลีนเทค, พลังงาน, สิ่งแวดล้อม แสงอาทิตย์, การจัดการของเสีย. เข้าถึงได้ที่นี่.
• BlockOffsets การปรับปรุงการเป็นเจ้าของออฟเซ็ตด้านสิ่งแวดล้อมให้ทันสมัย เข้าถึงได้ที่นี่.
• ที่มา: https://aws.amazon.com/blogs/machine-learning/maximize-stable-diffusion-performance-and-lower-inference-costs-with-aws-inferentia2/