เมื่อปรับใช้โมเดล Deep Learning ในปริมาณมาก จำเป็นอย่างยิ่งที่จะต้องใช้ฮาร์ดแวร์พื้นฐานอย่างมีประสิทธิภาพเพื่อเพิ่มประสิทธิภาพและความคุ้มค่าสูงสุด สำหรับปริมาณงานการผลิตที่ต้องการปริมาณงานสูงและเวลาแฝงต่ำ การเลือก อเมซอน อีลาสติก คอมพิวท์ คลาวด์ อินสแตนซ์ (EC2) โมเดลที่ให้บริการสแตก และสถาปัตยกรรมการปรับใช้มีความสำคัญมาก สถาปัตยกรรมที่ไม่มีประสิทธิภาพสามารถนำไปสู่การใช้ตัวเร่งความเร็วได้ไม่ดีเท่าที่ควรและต้นทุนการผลิตสูงโดยไม่จำเป็น
ในโพสต์นี้ เราจะอธิบายขั้นตอนการปรับใช้เซิร์ฟเวอร์โมเดล FastAPI บนอุปกรณ์ AWS Inferentia (พบได้ใน Amazon EC2 อินฟ1 และอเมซอน อีซี อินฟ2 ตัวอย่าง). นอกจากนี้ เรายังสาธิตการโฮสต์โมเดลตัวอย่างที่ปรับใช้แบบขนานใน NeuronCores ทั้งหมดเพื่อการใช้งานฮาร์ดแวร์สูงสุด
ภาพรวมโซลูชัน
FastAPI เป็นเว็บเฟรมเวิร์กโอเพ่นซอร์สสำหรับให้บริการแอปพลิเคชัน Python ซึ่งเร็วกว่าเฟรมเวิร์กดั้งเดิมอย่าง Flask และ Django มาก มันใช้ อินเทอร์เฟซเกตเวย์เซิร์ฟเวอร์แบบอะซิงโครนัส (ASGI) แทนที่ใช้กันอย่างแพร่หลาย อินเทอร์เฟซเกตเวย์เว็บเซิร์ฟเวอร์ (WSGI). ASGI ประมวลผลคำขอที่เข้ามาแบบอะซิงโครนัส ซึ่งตรงข้ามกับ WSGI ซึ่งประมวลผลคำขอตามลำดับ สิ่งนี้ทำให้ FastAPI เป็นตัวเลือกที่เหมาะสมที่สุดในการจัดการกับคำขอที่มีความอ่อนไหวต่อเวลาแฝง คุณสามารถใช้ FastAPI เพื่อปรับใช้เซิร์ฟเวอร์ที่โฮสต์จุดสิ้นสุดบนอินสแตนซ์ Inferentia (Inf1/Inf2) ที่รับฟังคำขอของไคลเอ็นต์ผ่านพอร์ตที่กำหนด
วัตถุประสงค์ของเราคือการได้รับประสิทธิภาพสูงสุดด้วยต้นทุนที่ต่ำที่สุดผ่านการใช้ประโยชน์สูงสุดจากฮาร์ดแวร์ สิ่งนี้ช่วยให้เราจัดการกับคำขอการอนุมานได้มากขึ้นโดยใช้ตัวเร่งความเร็วน้อยลง อุปกรณ์ AWS Inferentia1 แต่ละเครื่องมี NeuronCores-v1 สี่เครื่อง และอุปกรณ์ AWS Inferentia2 แต่ละเครื่องมี NeuronCores-v2 สองเครื่อง เดอะ AWS เซลล์ประสาท SDK ช่วยให้เราสามารถใช้ NeuronCores แต่ละตัวแบบคู่ขนานกัน ซึ่งทำให้เราควบคุมได้มากขึ้นในการโหลดและอนุมานโมเดลตั้งแต่ XNUMX โมเดลขึ้นไปพร้อมกันโดยไม่สูญเสียทรูพุต
ด้วย FastAPI คุณสามารถเลือกเว็บเซิร์ฟเวอร์ Python (กันนิคอร์น, ยูวิคอร์น, ไฮเปอร์คอร์น, ต้นแดฟนิ). เว็บเซิร์ฟเวอร์เหล่านี้จัดเตรียมและเลเยอร์นามธรรมไว้ด้านบนของโมเดลการเรียนรู้ของเครื่อง (ML) ไคลเอนต์ที่ร้องขอได้รับประโยชน์จากการถูกลืมรูปแบบที่โฮสต์ ไคลเอนต์ไม่จำเป็นต้องทราบชื่อรุ่นหรือเวอร์ชันที่ถูกปรับใช้ภายใต้เซิร์ฟเวอร์ ขณะนี้ชื่อปลายทางเป็นเพียงพร็อกซีของฟังก์ชันที่โหลดและรันโมเดล ในทางตรงกันข้าม ในเครื่องมือให้บริการเฉพาะเฟรมเวิร์ก เช่น TensorFlow Serving ชื่อและเวอร์ชันของโมเดลจะเป็นส่วนหนึ่งของชื่อปลายทาง หากโมเดลเปลี่ยนแปลงในฝั่งเซิร์ฟเวอร์ ไคลเอนต์ต้องทราบและเปลี่ยนการเรียก API ไปยังปลายทางใหม่ตามนั้น ดังนั้น หากคุณพัฒนาโมเดลเวอร์ชันอย่างต่อเนื่อง เช่น ในกรณีของการทดสอบ A/B การใช้เว็บเซิร์ฟเวอร์ Python ทั่วไปที่มี FastAPI จะเป็นวิธีที่สะดวกในการให้บริการโมเดล เนื่องจากชื่อจุดสิ้นสุดเป็นแบบคงที่
บทบาทของเซิร์ฟเวอร์ ASGI คือการวางไข่ตามจำนวนที่ระบุของผู้ปฏิบัติงานที่รับฟังคำขอของลูกค้าและเรียกใช้รหัสการอนุมาน ความสามารถที่สำคัญของเซิร์ฟเวอร์คือการทำให้แน่ใจว่าจำนวนผู้ปฏิบัติงานที่ร้องขอนั้นพร้อมใช้งานและทำงานอยู่ ในกรณีที่ผู้ปฏิบัติงานเสียชีวิต เซิร์ฟเวอร์จะต้องเปิดตัวผู้ปฏิบัติงานใหม่ ในบริบทนี้ เซิร์ฟเวอร์และผู้ปฏิบัติงานอาจถูกระบุโดยรหัสกระบวนการ Unix (PID) สำหรับโพสต์นี้ เราใช้ a ไฮเปอร์คอร์น เซิร์ฟเวอร์ซึ่งเป็นตัวเลือกยอดนิยมสำหรับเว็บเซิร์ฟเวอร์ Python
ในโพสต์นี้ เราแชร์แนวทางปฏิบัติที่ดีที่สุดในการปรับใช้โมเดลการเรียนรู้เชิงลึกด้วย FastAPI บน AWS Inferentia NeuronCores เราแสดงให้เห็นว่าคุณสามารถปรับใช้หลายรุ่นบน NeuronCores แยกกันซึ่งสามารถเรียกใช้พร้อมกันได้ การตั้งค่านี้เพิ่มปริมาณงานเนื่องจากสามารถอนุมานหลายรุ่นพร้อมกันได้ และการใช้งาน NeuronCore ได้รับการเพิ่มประสิทธิภาพอย่างเต็มที่ สามารถดูรหัสได้ที่ repo GitHub. รูปต่อไปนี้แสดงสถาปัตยกรรมของวิธีการตั้งค่าโซลูชันบนอินสแตนซ์ EC2 Inf2
สถาปัตยกรรมเดียวกันนี้ใช้กับประเภทอินสแตนซ์ EC2 Inf1 ยกเว้นว่าจะมีสี่คอร์ นั่นจึงเปลี่ยนไดอะแกรมสถาปัตยกรรมเล็กน้อย
AWS Inferentia NeuronCore
เรามาเจาะลึกเครื่องมือที่ AWS Neuron มอบให้เพื่อมีส่วนร่วมกับ NeuronCores กัน ตารางต่อไปนี้แสดงจำนวนของ NeuronCores ในอินสแตนซ์ Inf1 และ Inf2 แต่ละประเภท vCPU โฮสต์และหน่วยความจำระบบจะใช้ร่วมกันระหว่าง NeuronCores ที่มีทั้งหมด
ขนาดอินสแตนซ์ | # ตัวเร่ง Inferentia | #NeuronCores-v1 | vCPU | หน่วยความจำ (GiB) |
Inf1.xlarge | 1 | 4 | 4 | 8 |
Inf1.2xlarge | 1 | 4 | 8 | 16 |
Inf1.6xlarge | 4 | 16 | 24 | 48 |
Inf1.24xlarge | 16 | 64 | 96 | 192 |
ขนาดอินสแตนซ์ | # ตัวเร่ง Inferentia | #NeuronCores-v2 | vCPU | หน่วยความจำ (GiB) |
Inf2.xlarge | 1 | 2 | 4 | 32 |
Inf2.8xlarge | 1 | 2 | 32 | 32 |
Inf2.24xlarge | 6 | 12 | 96 | 192 |
Inf2.48xlarge | 12 | 24 | 192 | 384 |
อินสแตนซ์ Inf2 มี NeuronCores-v2 ใหม่เมื่อเปรียบเทียบกับ NeuronCore-v1 ในอินสแตนซ์ Inf1 แม้จะมีคอร์น้อยกว่า แต่ก็สามารถให้ทรูพุตที่สูงกว่าถึง 4 เท่าและเวลาแฝงที่ต่ำกว่าอินสแตนซ์ Inf10 ถึง 1 เท่า อินสแตนซ์ Inf2 เหมาะอย่างยิ่งสำหรับปริมาณงานการเรียนรู้เชิงลึก เช่น Generative AI, โมเดลภาษาขนาดใหญ่ (LLM) ในตระกูล OPT/GPT และตัวแปลงการมองเห็น เช่น Stable Diffusion
Neuron Runtime มีหน้าที่รับผิดชอบในการรันโมเดลบนอุปกรณ์ Neuron Neuron Runtime กำหนดว่า NeuronCore ใดที่จะรันโมเดลใดและจะรันอย่างไร การกำหนดค่าของ Neuron Runtime ถูกควบคุมผ่านการใช้ ตัวแปรสภาพแวดล้อม ในระดับกระบวนการ ตามค่าเริ่มต้น ส่วนขยายเฟรมเวิร์กของ Neuron จะดูแลการกำหนดค่า Neuron Runtime ในนามของผู้ใช้ อย่างไรก็ตาม การกำหนดค่าที่ชัดเจนยังเป็นไปได้เพื่อให้ได้ลักษณะการทำงานที่เหมาะสมยิ่งขึ้น
ตัวแปรสภาพแวดล้อมที่เป็นที่นิยมสองตัวแปรคือ NEURON_RT_NUM_CORES
และ NEURON_RT_VISIBLE_CORES
. ด้วยตัวแปรสภาพแวดล้อมเหล่านี้ กระบวนการ Python สามารถเชื่อมโยงกับ NeuronCore ได้ กับ NEURON_RT_NUM_CORES
สามารถจองจำนวนคอร์ที่ระบุสำหรับกระบวนการและด้วย NEURON_RT_VISIBLE_CORES
สามารถจองช่วงของ NeuronCores ได้ ตัวอย่างเช่น, NEURON_RT_NUM_CORES=2 myapp.py
จะจองสองคอร์และ NEURON_RT_VISIBLE_CORES=’0-2’ myapp.py
จะจองศูนย์หนึ่งและสองคอร์สำหรับ myapp.py
. คุณสามารถจอง NeuronCores ในอุปกรณ์ต่างๆ (ชิป AWS Inferentia) ได้เช่นกัน ดังนั้น, NEURON_RT_VISIBLE_CORES=’0-5’ myapp.py
จะสำรองสี่คอร์แรกไว้บน device1
และหนึ่งแกนบน device2
ในประเภทอินสแตนซ์ Ec2 Inf1 ในทำนองเดียวกัน ในประเภทอินสแตนซ์ EC2 Inf2 การกำหนดค่านี้จะจองสองคอร์ไว้ด้วยกัน device1
และ device2
และหนึ่งแกนบน device3
. ตารางต่อไปนี้สรุปการกำหนดค่าของตัวแปรเหล่านี้
Name | รายละเอียด | ชนิดภาพเขียน | ค่าที่คาดหวัง | ค่าเริ่มต้น | เวอร์ชั่น RT |
NEURON_RT_VISIBLE_CORES |
ช่วงของ NeuronCores เฉพาะที่กระบวนการต้องการ | ช่วงจำนวนเต็ม (เช่น 1-3) | ค่าใดๆ หรือช่วงระหว่าง 0 ถึง Max NeuronCore ในระบบ | ไม่มี | 2.0 + |
NEURON_RT_NUM_CORES |
จำนวนของ NeuronCores ที่กระบวนการต้องการ | จำนวนเต็ม | ค่าตั้งแต่ 1 ถึง Max NeuronCore ในระบบ | 0 ซึ่งแปลว่า "ทั้งหมด" | 2.0 + |
สำหรับรายการของตัวแปรสภาพแวดล้อมทั้งหมด โปรดดูที่ การกำหนดค่ารันไทม์ของเซลล์ประสาท.
ตามค่าเริ่มต้น เมื่อโหลดโมเดล โมเดลจะถูกโหลดไปยัง NeuronCore 0 และ NeuronCore 1 เว้นแต่จะระบุไว้อย่างชัดเจนโดยตัวแปรสภาพแวดล้อมก่อนหน้า ตามที่ระบุไว้ก่อนหน้านี้ NeuronCores แชร์ vCPU โฮสต์ที่มีอยู่และหน่วยความจำระบบ ดังนั้น โมเดลที่ติดตั้งบน NeuronCore แต่ละตัวจะแข่งขันกันเพื่อแย่งชิงทรัพยากรที่มีอยู่ สิ่งนี้จะไม่เป็นปัญหาหากโมเดลใช้ NeuronCores ในระดับมาก แต่ถ้าโมเดลทำงานเพียงบางส่วนบน NeuronCores และส่วนที่เหลือบนโฮสต์ vCPU การพิจารณาความพร้อมใช้งานของ CPU ต่อ NeuronCore จะมีความสำคัญ สิ่งนี้ส่งผลต่อการเลือกอินสแตนซ์เช่นกัน
ตารางต่อไปนี้แสดงจำนวน vCPU ของโฮสต์และหน่วยความจำระบบที่มีให้สำหรับแต่ละรุ่น หากมีการปรับใช้รุ่นใดรุ่นหนึ่งกับแต่ละ NeuronCore ขึ้นอยู่กับการใช้งาน NeuronCore, vCPU และการใช้หน่วยความจำของแอปพลิเคชันของคุณ ขอแนะนำให้ทำการทดสอบเพื่อดูว่าการกำหนดค่าใดมีประสิทธิภาพสูงสุดสำหรับแอปพลิเคชันของคุณ เดอะ เครื่องมือบนเซลล์ประสาท สามารถช่วยในการแสดงภาพการใช้งานหลักและการใช้งานหน่วยความจำอุปกรณ์และโฮสต์ จากเมตริกเหล่านี้ การตัดสินใจที่มีข้อมูลเพียงพอสามารถทำได้ เราสาธิตการใช้ Neuron Top ในตอนท้ายของบล็อกนี้
ขนาดอินสแตนซ์ | # ตัวเร่ง Inferentia | #โมเดล | vCPU/รุ่น | หน่วยความจำ/รุ่น (GiB) |
Inf1.xlarge | 1 | 4 | 1 | 2 |
Inf1.2xlarge | 1 | 4 | 2 | 4 |
Inf1.6xlarge | 4 | 16 | 1.5 | 3 |
Inf1.24xlarge | 16 | 64 | 1.5 | 3 |
ขนาดอินสแตนซ์ | # ตัวเร่ง Inferentia | #โมเดล | vCPU/รุ่น | หน่วยความจำ/รุ่น (GiB) |
Inf2.xlarge | 1 | 2 | 2 | 8 |
Inf2.8xlarge | 1 | 2 | 16 | 64 |
Inf2.24xlarge | 6 | 12 | 8 | 32 |
Inf2.48xlarge | 12 | 24 | 8 | 32 |
หากต้องการทดสอบคุณสมบัติ Neuron SDK ด้วยตนเอง โปรดดูที่ล่าสุด ความสามารถของเซลล์ประสาทสำหรับ PyTorch.
ติดตั้งระบบ
ต่อไปนี้คือการตั้งค่าระบบที่ใช้สำหรับโซลูชันนี้:
ตั้งค่าโซลูชัน
มีสองสิ่งที่เราต้องทำเพื่อตั้งค่าโซลูชัน เริ่มต้นด้วยการสร้างบทบาท IAM ที่อินสแตนซ์ EC2 ของคุณจะอนุมานว่าจะอนุญาตให้ผลักและดึงจาก การลงทะเบียน Amazon Elastic Container.
ขั้นตอนที่ 1: ตั้งค่าบทบาท IAM
- เริ่มต้นด้วยการลงชื่อเข้าใช้คอนโซลและเข้าถึง IAM > บทบาท > สร้างบทบาท
- เลือกประเภทเอนทิตีที่เชื่อถือได้
AWS Service
- เลือก EC2 เป็นบริการภายใต้กรณีการใช้งาน
- คลิก ถัดไป และคุณจะสามารถเห็นนโยบายทั้งหมดที่มี
- เพื่อจุดประสงค์ของการแก้ปัญหานี้ เราจะให้อินสแตนซ์ EC2 ของเราเข้าถึง ECR ได้อย่างเต็มที่ กรองสำหรับ AmazonEC2ContainerRegistryFullAccess และเลือก
- กดถัดไปและตั้งชื่อบทบาท
inf-ecr-access
หมายเหตุ: นโยบายที่เราแนบให้อินสแตนซ์ EC2 เข้าถึง Amazon ECR ได้อย่างเต็มที่ เราขอแนะนำให้ปฏิบัติตาม หลักของสิทธิพิเศษน้อยที่สุด สำหรับปริมาณงานการผลิต
ขั้นตอนที่ 2: ตั้งค่า AWS CLI
หากคุณกำลังใช้ Deep Learning AMI ที่ระบุไว้ข้างต้น AWS จะมาพร้อมกับ AWS CLI ที่ติดตั้งไว้ หากคุณใช้ AMI อื่น (Amazon Linux 2023, Base Ubuntu เป็นต้น) ให้ติดตั้งเครื่องมือ CLI โดยทำตามนี้ คู่มือนี้.
เมื่อคุณติดตั้งเครื่องมือ CLI แล้ว ให้กำหนดค่า CLI โดยใช้คำสั่ง aws configure
. หากคุณมีคีย์การเข้าถึง คุณสามารถเพิ่มที่นี่ได้ แต่ไม่จำเป็นต้องใช้เพื่อโต้ตอบกับบริการของ AWS เราอาศัยบทบาท IAM ในการดำเนินการดังกล่าว
หมายเหตุ: เราจำเป็นต้องป้อนค่าอย่างน้อยหนึ่งค่า (ภูมิภาคเริ่มต้นหรือรูปแบบเริ่มต้น) เพื่อสร้างโปรไฟล์เริ่มต้น สำหรับตัวอย่างนี้ เราจะไปกับ us-east-2
เป็นภูมิภาคและ json
เป็นเอาต์พุตเริ่มต้น
โคลนที่เก็บ Github
พื้นที่ repo GitHub จัดเตรียมสคริปต์ทั้งหมดที่จำเป็นในการปรับใช้โมเดลโดยใช้ FastAPI บน NeuronCores บนอินสแตนซ์ AWS Inferentia ตัวอย่างนี้ใช้คอนเทนเนอร์ Docker เพื่อให้แน่ใจว่าเราสามารถสร้างโซลูชันที่ใช้ซ้ำได้ ในตัวอย่างนี้มีดังต่อไปนี้ config.คุณสมบัติ ไฟล์เพื่อให้ผู้ใช้ป้อนข้อมูล
ไฟล์การกำหนดค่าต้องมีคำนำหน้าชื่อที่ผู้ใช้กำหนดสำหรับอิมเมจ Docker และคอนเทนเนอร์ Docker เดอะ build.sh
สคริปต์ใน fastapi
และ trace-model
โฟลเดอร์ใช้สิ่งนี้เพื่อสร้างอิมเมจ Docker
รวบรวมแบบจำลองบน AWS Inferentia
เราจะเริ่มต้นด้วยการติดตามโมเดลและสร้างไฟล์ PyTorch Torchscript .pt เริ่มต้นด้วยการเข้าถึง trace-model
ไดเร็กทอรีและแก้ไขไฟล์ .env ขึ้นอยู่กับประเภทของอินสแตนซ์ที่คุณเลือก แก้ไข CHIP_TYPE
ภายใน .env
ไฟล์. ตัวอย่างเช่น เราจะเลือก Inf2 เป็นแนวทาง ขั้นตอนเดียวกันนี้ใช้กับกระบวนการปรับใช้สำหรับ Inf1
ถัดไปตั้งค่าภูมิภาคเริ่มต้นในไฟล์เดียวกัน ภูมิภาคนี้จะใช้เพื่อสร้างที่เก็บ ECR และอิมเมจ Docker จะถูกพุชไปยังที่เก็บนี้ นอกจากนี้ ในโฟลเดอร์นี้ เราจัดเตรียมสคริปต์ทั้งหมดที่จำเป็นในการติดตาม bert-base-uncased
โมเดลบน AWS Inferentia สคริปต์นี้สามารถใช้ได้กับโมเดลส่วนใหญ่ที่มีใน กอดหน้า. ไฟล์นักเทียบท่า มีการอ้างอิงทั้งหมดเพื่อรันโมเดลด้วย Neuron และรัน ติดตาม model.py รหัสเป็นจุดเริ่มต้น
อธิบายการรวบรวมเซลล์ประสาท
API ของ Neuron SDK คล้ายกับ PyTorch Python API อย่างใกล้ชิด เดอะ torch.jit.trace()
จาก PyTorch ใช้โมเดลและเทนเซอร์อินพุตตัวอย่างเป็นอาร์กิวเมนต์ อินพุตตัวอย่างถูกป้อนไปยังโมเดลและการดำเนินการที่เรียกใช้เมื่ออินพุตนั้นผ่านเลเยอร์ของโมเดลจะถูกบันทึกเป็น ทอร์ชสคริปต์. หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ JIT Tracing ใน PyTorch โปรดดูต่อไปนี้ เอกสาร.
เช่นเดียวกับ torch.jit.trace()
คุณสามารถตรวจสอบว่าโมเดลของคุณสามารถคอมไพล์บน AWS Inferentia ด้วยโค้ดต่อไปนี้สำหรับอินสแตนซ์ inf1 ได้หรือไม่
สำหรับ inf2 ไลบรารีจะถูกเรียก torch_neuronx
. ต่อไปนี้คือวิธีที่คุณสามารถทดสอบการคอมไพล์โมเดลของคุณกับอินสแตนซ์ inf2
หลังจากสร้างตัวอย่างการติดตามแล้ว เราสามารถส่งอินพุตเทนเซอร์ตัวอย่างดังนี้:
และสุดท้ายบันทึกผลลัพธ์ของ TorchScript บนดิสก์ภายในเครื่อง
ตามที่แสดงในรหัสก่อนหน้า คุณสามารถใช้ compiler_args
และ optimizations
เพื่อเพิ่มประสิทธิภาพการปรับใช้ สำหรับรายการอาร์กิวเมนต์โดยละเอียดสำหรับ torch.neuron.trace
API อ้างถึง PyTorch-Neuron ติดตาม python API.
คำนึงถึงประเด็นสำคัญต่อไปนี้:
- Neuron SDK ไม่รองรับรูปร่างของเทนเซอร์แบบไดนามิกในขณะที่เขียนบทความนี้ ดังนั้น จะต้องรวบรวมแบบจำลองแยกต่างหากสำหรับรูปร่างอินพุตที่แตกต่างกัน สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการเรียกใช้การอนุมานในรูปร่างอินพุตตัวแปรพร้อมการจัดกลุ่ม โปรดดูที่ ใช้การอนุมานกับรูปร่างอินพุตแบบแปรผันด้วยการฝากข้อมูล.
- หากคุณประสบปัญหาหน่วยความจำเมื่อคอมไพล์โมเดล ให้ลองคอมไพล์โมเดลบนอินสแตนซ์ AWS Inferentia ที่มี vCPU หรือหน่วยความจำมากขึ้น หรือแม้แต่อินสแตนซ์ c6i หรือ r6i ขนาดใหญ่เนื่องจากการคอมไพล์ใช้ CPU เท่านั้น เมื่อคอมไพล์แล้ว โมเดลที่ติดตามสามารถเรียกใช้บนอินสแตนซ์ AWS Inferentia ที่มีขนาดเล็กกว่าได้
คำอธิบายกระบวนการสร้าง
ตอนนี้เราจะสร้างคอนเทนเนอร์นี้โดยเรียกใช้ สร้าง.sh. ไฟล์สคริปต์บิลด์เพียงแค่สร้างอิมเมจ Docker โดยดึง Deep Learning Container Image พื้นฐานและติดตั้ง HuggingFace transformers
บรรจุุภัณฑ์. ขึ้นอยู่กับ CHIP_TYPE
ระบุไว้ใน .env
ไฟล์ the docker.properties
ไฟล์ตัดสินใจที่เหมาะสม BASE_IMAGE
. นี้ BASE_IMAGE
ชี้ไปที่ Deep Learning Container Image สำหรับ Neuron Runtime ที่ AWS จัดหาให้
มีให้ใช้งานผ่านที่เก็บ ECR ส่วนตัว ก่อนที่เราจะดึงอิมเมจได้ เราต้องเข้าสู่ระบบและรับข้อมูลรับรอง AWS ชั่วคราว
หมายเหตุ: เราจำเป็นต้องแทนที่ภูมิภาคที่แสดงในคำสั่งที่ระบุโดยธงภูมิภาคและภายในที่เก็บ URI ด้วยภูมิภาคที่เราใส่ใน .env ไฟล์
เพื่อให้กระบวนการนี้ง่ายขึ้น เราสามารถใช้ fetch-credentials.sh
ไฟล์. ภูมิภาคจะถูกนำมาจากไฟล์ .env โดยอัตโนมัติ
ต่อไปเราจะพุชรูปภาพโดยใช้สคริปต์ ดัน.sh. สคริปต์พุชสร้างที่เก็บใน Amazon ECR ให้คุณและพุชอิมเมจคอนเทนเนอร์
ในที่สุดเมื่อสร้างอิมเมจและพุชแล้ว เราสามารถรันมันเป็นคอนเทนเนอร์ได้ด้วยการรัน วิ่ง.ช และหางวิ่งล็อกด้วย log.sh. ในบันทึกของคอมไพลเลอร์ (ดูภาพหน้าจอต่อไปนี้) คุณจะเห็นเปอร์เซ็นต์ของตัวดำเนินการทางคณิตศาสตร์ที่รวบรวมบน Neuron และเปอร์เซ็นต์ของกราฟย่อยของโมเดลที่รวบรวมสำเร็จบน Neuron ภาพหน้าจอแสดงบันทึกของคอมไพเลอร์สำหรับ bert-base-uncased-squad2
แบบอย่าง. บันทึกแสดงให้เห็นว่า 95.64% ของตัวดำเนินการทางคณิตศาสตร์ได้รับการรวบรวม และยังให้รายชื่อตัวดำเนินการที่รวบรวมบน Neuron และตัวดำเนินการที่ไม่ได้รับการสนับสนุน
นี่คือรายการ ของตัวดำเนินการที่รองรับทั้งหมดในแพ็คเกจ PyTorch Neuron ล่าสุด ในทำนองเดียวกัน นี่คือรายการ ของโอเปอเรเตอร์ที่รองรับทั้งหมดในแพ็คเกจ PyTorch Neuronx ล่าสุด
ปรับใช้โมเดลด้วย FastAPI
หลังจากรวบรวมโมเดลแล้ว โมเดลที่ติดตามจะปรากฏใน trace-model
โฟลเดอร์ ในตัวอย่างนี้ เราได้วางโมเดลที่ติดตามสำหรับขนาดแบทช์ที่ 1 เราพิจารณาขนาดแบทช์ที่ 1 ที่นี่เพื่อพิจารณากรณีการใช้งานเหล่านั้น ซึ่งขนาดแบทช์ที่สูงกว่านั้นไม่สามารถทำได้หรือไม่จำเป็นต้องใช้ สำหรับกรณีการใช้งานที่ต้องการขนาดแบทช์ที่สูงขึ้น torch.neuron.DataParallel (สำหรับ Inf1) หรือ torch.neuronx.DataParallel (สำหรับ Inf2) API อาจมีประโยชน์เช่นกัน
พื้นที่ รวดเร็ว API โฟลเดอร์จัดเตรียมสคริปต์ที่จำเป็นทั้งหมดเพื่อปรับใช้โมเดลด้วย FastAPI ในการปรับใช้โมเดลโดยไม่มีการเปลี่ยนแปลงใดๆ เพียงเรียกใช้ ปรับใช้.sh สคริปต์และจะสร้างอิมเมจคอนเทนเนอร์ FastAPI รันคอนเทนเนอร์ตามจำนวนแกนที่ระบุ และปรับใช้จำนวนรุ่นที่ระบุต่อเซิร์ฟเวอร์ในแต่ละเซิร์ฟเวอร์โมเดล FastAPI โฟลเดอร์นี้ยังมีไฟล์ .env
ไฟล์แก้ไขเพื่อให้สะท้อนถึงความถูกต้อง CHIP_TYPE
และ AWS_DEFAULT_REGION
.
หมายเหตุ: สคริปต์ FastAPI ใช้ตัวแปรสภาพแวดล้อมเดียวกับที่ใช้ในการสร้าง พุช และเรียกใช้อิมเมจเป็นคอนเทนเนอร์ สคริปต์การปรับใช้ FastAPI จะใช้ค่าที่ทราบล่าสุดจากตัวแปรเหล่านี้ ดังนั้น หากคุณติดตามโมเดลสำหรับประเภทอินสแตนซ์ Inf1 สุดท้าย โมเดลนั้นจะถูกปรับใช้ผ่านสคริปต์เหล่านี้
พื้นที่ fastapi-server.py ไฟล์ที่รับผิดชอบในการโฮสต์เซิร์ฟเวอร์และส่งคำขอไปยังโมเดลมีดังต่อไปนี้:
- อ่านจำนวนโมเดลต่อเซิร์ฟเวอร์และตำแหน่งของโมเดลที่คอมไพล์จากไฟล์คุณสมบัติ
- ตั้งค่า NeuronCores ที่มองเห็นเป็นตัวแปรสภาพแวดล้อมให้กับคอนเทนเนอร์ Docker และอ่านตัวแปรสภาพแวดล้อมเพื่อระบุ NeuronCores ที่จะใช้
- ให้ API การอนุมานสำหรับ
bert-base-uncased-squad2
แบบ - กับ
jit.load()
โหลดจำนวนรุ่นต่อเซิร์ฟเวอร์ตามที่ระบุในการกำหนดค่าและจัดเก็บรุ่นและโทเค็นที่จำเป็นในพจนานุกรมส่วนกลาง
ด้วยการตั้งค่านี้ การตั้งค่า API จะแสดงรายการโมเดลและจำนวนโมเดลที่จัดเก็บไว้ใน NeuronCore แต่ละอันจะค่อนข้างง่าย ในทำนองเดียวกัน สามารถเขียน API เพื่อลบโมเดลออกจาก NeuronCores เฉพาะได้
พื้นที่ ไฟล์นักเทียบท่า สำหรับการสร้างคอนเทนเนอร์ FastAPI นั้นสร้างขึ้นบนอิมเมจ Docker ที่เราสร้างขึ้นเพื่อติดตามโมเดล นี่คือเหตุผลที่ นักเทียบท่าคุณสมบัติ ไฟล์ระบุเส้นทาง ECR ไปยังอิมเมจ Docker เพื่อติดตามโมเดล ในการตั้งค่าของเรา คอนเทนเนอร์ Docker ใน NeuronCores ทั้งหมดจะคล้ายกัน เราจึงสามารถสร้างอิมเมจเดียวและเรียกใช้หลายคอนเทนเนอร์จากอิมเมจเดียวได้ เราระบุเพื่อหลีกเลี่ยงข้อผิดพลาดของจุดเข้าใช้งาน ENTRYPOINT ["/usr/bin/env"]
ใน Dockerfile ก่อนเรียกใช้ไฟล์ startup.sh
สคริปต์ซึ่งดูเหมือนว่า hypercorn fastapi-server:app -b 0.0.0.0:8080
. สคริปต์เริ่มต้นนี้เหมือนกันสำหรับคอนเทนเนอร์ทั้งหมด หากคุณใช้อิมเมจพื้นฐานเดียวกันกับโมเดลการติดตาม คุณสามารถสร้างคอนเทนเนอร์นี้ได้โดยเรียกใช้สคริปต์ build.sh เดอะ push.sh
สคริปต์ยังคงเหมือนเดิมสำหรับโมเดลการติดตาม อิมเมจ Docker ที่แก้ไขแล้วและชื่อคอนเทนเนอร์มีให้โดย docker.properties
ไฟล์
พื้นที่ run.sh file
ทำสิ่งต่อไปนี้:
- อ่านอิมเมจ Docker และชื่อคอนเทนเนอร์จากไฟล์ คุณสมบัติ ไฟล์ซึ่งจะอ่านไฟล์
config.properties
ซึ่งมีไฟล์num_cores
การตั้งค่าผู้ใช้ - เริ่มวนรอบจาก 0 ถึง
num_cores
และสำหรับแต่ละคอร์:- ตั้งค่าหมายเลขพอร์ตและหมายเลขอุปกรณ์
- ตั้งค่า
NEURON_RT_VISIBLE_CORES
ตัวแปรสภาพแวดล้อม - ระบุการเมานต์ไดรฟ์ข้อมูล
- เรียกใช้คอนเทนเนอร์ Docker
เพื่อความชัดเจน คำสั่งเรียกใช้ Docker สำหรับการปรับใช้ใน NeuronCore 0 สำหรับ Inf1 จะมีลักษณะดังนี้:
คำสั่งเรียกใช้สำหรับการปรับใช้ใน NeuronCore 5 จะมีลักษณะดังนี้:
หลังจากปรับใช้คอนเทนเนอร์แล้ว เราจะใช้ run_apis.py สคริปต์ซึ่งเรียกใช้ API ในเธรดแบบขนาน รหัสถูกตั้งค่าให้เรียกใช้โมเดลหกตัวที่ใช้งานอยู่ แต่ละโมเดลบน NeuronCore แต่สามารถเปลี่ยนเป็นการตั้งค่าอื่นได้อย่างง่ายดาย เราเรียก API จากฝั่งไคลเอนต์ดังนี้:
ตรวจสอบ NeuronCore
หลังจากปรับใช้เซิร์ฟเวอร์รุ่นแล้ว เราอาจใช้เพื่อตรวจสอบการใช้งาน NeuronCore neuron-top
เพื่อสังเกตเปอร์เซ็นต์การใช้งานของ NeuronCore แต่ละอันตามเวลาจริง เซลล์ประสาทด้านบน เป็นเครื่องมือ CLI ใน Neuron SDK เพื่อให้ข้อมูลต่างๆ เช่น NeuronCore, vCPU และการใช้หน่วยความจำ ในเทอร์มินัลที่แยกต่างหาก ให้ป้อนคำสั่งต่อไปนี้:
ผลลัพธ์ของคุณควรคล้ายกับรูปต่อไปนี้ ในสถานการณ์สมมตินี้ เราได้กำหนดให้ใช้ NeuronCores สองชุดและสองรุ่นต่อเซิร์ฟเวอร์บนอินสแตนซ์ Inf2.xlarge ภาพหน้าจอต่อไปนี้แสดงให้เห็นว่าแต่ละรุ่นขนาด 287.8MB โหลดบน NeuronCore สองตัว เมื่อโหลดรุ่นทั้งหมด 4 รุ่น คุณจะเห็นว่าหน่วยความจำอุปกรณ์ที่ใช้คือ 1.3 GB ใช้แป้นลูกศรเพื่อย้ายไปมาระหว่าง NeuronCores บนอุปกรณ์ต่างๆ
ในประเภทอินสแตนซ์ Inf1.16xlarge เราเห็นโมเดลทั้งหมด 12 โมเดล (2 โมเดลต่อคอร์ใน 6 คอร์) ใช้หน่วยความจำรวม 2.1GB และทุกรุ่นมีขนาด 177.2MB
หลังจากที่คุณเรียกใช้ไฟล์ run_apis.py สคริปต์ คุณสามารถดูเปอร์เซ็นต์ของการใช้งาน NeuronCore แต่ละตัวจากหกตัว (ดูภาพหน้าจอต่อไปนี้) คุณยังสามารถดูการใช้งาน vCPU ของระบบและการใช้งาน vCPU รันไทม์ได้อีกด้วย
ภาพหน้าจอต่อไปนี้แสดงเปอร์เซ็นต์การใช้งานหลักของอินสแตนซ์ Inf2
ในทำนองเดียวกัน ภาพหน้าจอนี้แสดงการใช้งานหลักในประเภทอินสแตนซ์ inf1.6xlarge
ทำความสะอาด
ในการล้างคอนเทนเนอร์ Docker ทั้งหมดที่คุณสร้างขึ้น เรามี cleanup.sh สคริปต์ที่ลบคอนเทนเนอร์ที่กำลังทำงานและหยุดทำงานทั้งหมด สคริปต์นี้จะลบคอนเทนเนอร์ทั้งหมด ดังนั้นอย่าใช้หากคุณต้องการให้คอนเทนเนอร์บางส่วนทำงานต่อไป
สรุป
ปริมาณงานการผลิตมักมีปริมาณงานสูง เวลาแฝงต่ำ และความต้องการด้านต้นทุน สถาปัตยกรรมที่ไม่มีประสิทธิภาพซึ่งใช้ตัวเร่งความเร็วต่ำกว่าปกติอาจนำไปสู่ต้นทุนการผลิตที่สูงโดยไม่จำเป็น ในโพสต์นี้ เราได้แสดงวิธีใช้ NeuronCores ร่วมกับ FastAPI อย่างเหมาะสมเพื่อเพิ่มทรูพุตให้ได้สูงสุดโดยมีเวลาแฝงน้อยที่สุด เราได้เผยแพร่คำแนะนำเกี่ยวกับของเรา repo GitHub. ด้วยสถาปัตยกรรมโซลูชันนี้ คุณสามารถปรับใช้หลายรุ่นในแต่ละ NeuronCore และใช้งานหลายรุ่นพร้อมกันบน NeuronCores ที่แตกต่างกันโดยไม่สูญเสียประสิทธิภาพ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีปรับใช้โมเดลตามขนาดด้วยบริการต่างๆ เช่น บริการ Amazon Elastic Kubernetes (Amazon EKS) อ้างถึง ให้บริการโมเดลการเรียนรู้เชิงลึก 3,000 รายการบน Amazon EKS ด้วย AWS Inferentia ในราคาต่ำกว่า 50 ดอลลาร์ต่อชั่วโมง.
เกี่ยวกับผู้แต่ง
อังกูร ศรีสวัสดิ์ เป็น Sr. Solutions Architect ในทีม ML Frameworks เขามุ่งเน้นที่การช่วยเหลือลูกค้าด้วยการฝึกอบรมแบบกระจายที่จัดการด้วยตนเองและการอนุมานบน AWS ประสบการณ์ของเขารวมถึงการบำรุงรักษาเชิงคาดการณ์ทางอุตสาหกรรม ฝาแฝดดิจิทัล การเพิ่มประสิทธิภาพการออกแบบที่น่าจะเป็นไปได้ และสำเร็จการศึกษาระดับปริญญาเอกจากวิศวกรรมเครื่องกลที่มหาวิทยาลัยไรซ์ และการวิจัยระดับหลังปริญญาเอกจากสถาบันเทคโนโลยีแมสซาชูเซตส์
เคซี ตุ้ง เป็นสถาปนิกโซลูชันอาวุโสใน AWS Annapurna Labs เขาเชี่ยวชาญในการฝึกอบรมโมเดลการเรียนรู้เชิงลึกขนาดใหญ่และการปรับใช้ในระดับบนคลาวด์ เขามีปริญญาเอก สาขาชีวฟิสิกส์ระดับโมเลกุล จาก University of Texas Southwestern Medical Center ในดัลลัส เขาได้พูดที่ AWS Summits และ AWS Reinvent วันนี้เขาช่วยลูกค้าในการฝึกอบรมและปรับใช้โมเดล PyTorch และ TensorFlow ขนาดใหญ่ใน AWS Cloud เขาเป็นผู้แต่งหนังสือสองเล่ม: เรียนรู้ TensorFlow Enterprise และ การอ้างอิงพ็อกเก็ต TensorFlow 2.
โปรนอย โชปรา เป็นสถาปนิกโซลูชันอาวุโสกับทีม Startups Generative AI ที่ AWS เขาเชี่ยวชาญด้านการออกแบบสถาปัตยกรรมและการพัฒนาโซลูชัน IoT และการเรียนรู้ของเครื่อง เขาเคยร่วมก่อตั้งบริษัทสตาร์ทอัพสองแห่งในอดีต และสนุกกับการลงมือปฏิบัติจริงกับโครงการต่างๆ ในโดเมน IoT, AI/ML และ Serverless
- เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
- PlatoData.Network Vertical Generative Ai เพิ่มพลังให้กับตัวเอง เข้าถึงได้ที่นี่.
- เพลโตไอสตรีม. Web3 อัจฉริยะ ขยายความรู้ เข้าถึงได้ที่นี่.
- เพลโตESG. ยานยนต์ / EVs, คาร์บอน, คลีนเทค, พลังงาน, สิ่งแวดล้อม แสงอาทิตย์, การจัดการของเสีย. เข้าถึงได้ที่นี่.
- BlockOffsets การปรับปรุงการเป็นเจ้าของออฟเซ็ตด้านสิ่งแวดล้อมให้ทันสมัย เข้าถึงได้ที่นี่.
- ที่มา: https://aws.amazon.com/blogs/machine-learning/optimize-aws-inferentia-utilization-with-fastapi-and-pytorch-models-on-amazon-ec2-inf1-inf2-instances/
- :มี
- :เป็น
- :ไม่
- :ที่ไหน
- $ ขึ้น
- 000
- 1
- 1.3
- 10
- 100
- 12
- 13
- 15%
- 2023
- 7
- 8
- 91
- a
- สามารถ
- เกี่ยวกับเรา
- ข้างบน
- สิ่งที่เป็นนามธรรม
- เร่ง
- เข้า
- การเข้าถึง
- ตาม
- ลงชื่อเข้าใช้
- บรรลุ
- ข้าม
- คล่องแคล่ว
- เพิ่ม
- กับ
- AI
- AI / ML
- ทั้งหมด
- อนุญาต
- ช่วยให้
- ด้วย
- อเมซอน
- Amazon EC2
- Amazon Web Services
- an
- และ
- ใด
- API
- APIs
- app
- การใช้งาน
- การใช้งาน
- ใช้
- เหมาะสม
- สถาปัตยกรรม
- เป็น
- ข้อโต้แย้ง
- AS
- สมมติ
- At
- ผู้เขียน
- อัตโนมัติ
- ความพร้อมใช้งาน
- ใช้ได้
- หลีกเลี่ยง
- AWS
- การอนุมาน AWS
- ฐาน
- ตาม
- BE
- เพราะ
- กลายเป็น
- รับ
- ก่อน
- ตัวแทน
- พฤติกรรม
- กำลัง
- ประโยชน์
- ประโยชน์ที่ได้รับ
- ที่ดีที่สุด
- ปฏิบัติที่ดีที่สุด
- ระหว่าง
- ชีวฟิสิกส์
- บิต
- บล็อก
- ร้านหนังสือเกาหลี
- สร้าง
- การก่อสร้าง
- สร้าง
- แต่
- by
- โทรศัพท์
- ที่เรียกว่า
- โทร
- CAN
- ความสามารถในการ
- ความสามารถ
- ซึ่ง
- กรณี
- กรณี
- ศูนย์
- เปลี่ยนแปลง
- การเปลี่ยนแปลง
- การเปลี่ยนแปลง
- ตรวจสอบ
- ชิป
- ทางเลือก
- Choose
- เลือก
- ความชัดเจน
- ไคลเอนต์
- อย่างใกล้ชิด
- เมฆ
- รหัส
- มา
- การเปรียบเทียบ
- แข่งขัน
- เสร็จ
- คำนวณ
- องค์ประกอบ
- พิจารณา
- พิจารณา
- ปลอบใจ
- ถูกใช้
- บรรจุ
- ภาชนะ
- ภาชนะบรรจุ
- มี
- สิ่งแวดล้อม
- อย่างต่อเนื่อง
- ตรงกันข้าม
- ควบคุม
- การควบคุม
- สะดวกสบาย
- แกน
- แก้ไข
- ราคา
- ค่าใช้จ่าย
- ได้
- คู่
- สร้าง
- ที่สร้างขึ้น
- สร้าง
- การสร้าง
- หนังสือรับรอง
- สำคัญมาก
- ลูกค้า
- ดัลลัส
- การตัดสินใจ
- ลึก
- การเรียนรู้ลึก ๆ
- ลึก
- ค่าเริ่มต้น
- สาธิต
- ทั้งนี้ขึ้นอยู่กับ
- ปรับใช้
- นำไปใช้
- ปรับใช้
- การใช้งาน
- ออกแบบ
- กำหนด
- แม้จะมี
- รายละเอียด
- แน่นอน
- ที่กำลังพัฒนา
- เครื่อง
- อุปกรณ์
- ต่าง
- การจัดจำหน่าย
- DIG
- ดิจิตอล
- ฝาแฝดดิจิทัล
- กระจาย
- กระจายการฝึกอบรม
- Django
- do
- นักเทียบท่า
- ทำ
- ไม่
- โดเมน
- Dont
- พลวัต
- แต่ละ
- ก่อน
- ง่ายดาย
- อย่างง่ายดาย
- ง่าย
- EC
- มีประสิทธิภาพ
- ปลาย
- ปลายทาง
- ว่าจ้าง
- ชั้นเยี่ยม
- ทำให้มั่นใจ
- เข้าสู่
- เอกลักษณ์
- การเข้า
- สิ่งแวดล้อม
- ข้อผิดพลาด
- ฯลฯ
- แม้
- ทุกๆ
- การพัฒนา
- ตัวอย่าง
- ยกเว้น
- ประสบการณ์
- ส่วนขยาย
- ใบหน้า
- ครอบครัว
- เร็วขึ้น
- เป็นไปได้
- คุณสมบัติ
- เฟด
- น้อยลง
- รูป
- เนื้อไม่มีมัน
- กรอง
- ในที่สุด
- หา
- ชื่อจริง
- มุ่งเน้นไปที่
- ดังต่อไปนี้
- ดังต่อไปนี้
- สำหรับ
- รูป
- พบ
- สี่
- กรอบ
- กรอบ
- ราคาเริ่มต้นที่
- เต็ม
- อย่างเต็มที่
- ฟังก์ชัน
- เกตเวย์
- กำเนิด
- กำเนิด AI
- ได้รับ
- GitHub
- ให้
- จะช่วยให้
- เหตุการณ์ที่
- ไป
- ให้คำแนะนำ
- จัดการ
- มือบน
- ฮาร์ดแวร์
- มี
- he
- ช่วย
- การช่วยเหลือ
- จะช่วยให้
- โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม
- จุดสูง
- สูงกว่า
- ที่สูงที่สุด
- ของเขา
- เจ้าภาพ
- เป็นเจ้าภาพ
- โฮสติ้ง
- เจ้าภาพ
- สรุป ความน่าเชื่อถือของ Olymp Trade?
- ทำอย่างไร
- อย่างไรก็ตาม
- HTML
- ที่ http
- HTTPS
- กอดใบหน้า
- ID
- ในอุดมคติ
- ระบุ
- if
- ภาพ
- ภาพ
- นำเข้า
- สำคัญ
- in
- รวม
- รวมถึง
- ขาเข้า
- เพิ่มขึ้น
- อุตสาหกรรม
- ไม่มีประสิทธิภาพ
- ข้อมูล
- แจ้ง
- อินพุต
- ปัจจัยการผลิต
- ติดตั้ง
- การติดตั้ง
- การติดตั้ง
- ตัวอย่าง
- แทน
- สถาบัน
- คำแนะนำการใช้
- โต้ตอบ
- เข้าไป
- เรียก
- IOT
- ปัญหา
- ปัญหา
- IT
- ITS
- JIT
- jpg
- เพียงแค่
- เก็บ
- กุญแจ
- ทราบ
- ที่รู้จักกัน
- ห้องปฏิบัติการ
- ภาษา
- ใหญ่
- ชื่อสกุล
- ความแอบแฝง
- ล่าสุด
- เปิดตัว
- ชั้น
- ชั้น
- นำ
- เรียนรู้
- การเรียนรู้
- ชั้น
- ห้องสมุด
- กดไลก์
- ลินุกซ์
- รายการ
- จดทะเบียน
- น้อย
- ลึกหน่อย
- LLM
- โหลด
- โหลด
- ในประเทศ
- ที่ตั้ง
- การเข้าสู่ระบบ
- เข้าสู่ระบบ
- ดู
- ดูเหมือน
- LOOKS
- แพ้
- ต่ำ
- ลด
- ต่ำที่สุด
- เครื่อง
- เรียนรู้เครื่อง
- ทำ
- การบำรุงรักษา
- ทำ
- ทำให้
- การทำ
- หลาย
- แมสซาชูเซต
- สถาบันเทคโนโลยีแมสซาชูเซตส์
- แม็กซ์
- เพิ่ม
- สูงสุด
- อาจ..
- เชิงกล
- ทางการแพทย์
- หน่วยความจำ
- ตัวชี้วัด
- ใจ
- ขั้นต่ำ
- ML
- แบบ
- โมเดล
- การแก้ไข
- แก้ไข
- โมเลกุล
- การตรวจสอบ
- ข้อมูลเพิ่มเติม
- มากที่สุด
- ย้าย
- มาก
- หลาย
- ต้อง
- ชื่อ
- จำเป็นต้อง
- จำเป็น
- จำเป็นต้อง
- จำเป็น
- ความต้องการ
- ใหม่
- ถัดไป
- ตอนนี้
- จำนวน
- วัตถุประสงค์
- สังเกต
- of
- เสนอ
- มักจะ
- on
- ครั้งเดียว
- ONE
- เพียง
- ไปยัง
- โอเพนซอร์ส
- ทำงาน
- การดำเนินการ
- ผู้ประกอบการ
- ตรงข้าม
- การเพิ่มประสิทธิภาพ
- เพิ่มประสิทธิภาพ
- การปรับให้เหมาะสม
- or
- ของเรา
- ออก
- เอาท์พุต
- เกิน
- แพ็คเกจ
- Parallel
- ส่วนหนึ่ง
- ส่ง
- อดีต
- เส้นทาง
- ต่อ
- เปอร์เซ็นต์
- การปฏิบัติ
- เพลโต
- เพลโตดาต้าอินเทลลิเจนซ์
- เพลโตดาต้า
- จุด
- จุด
- นโยบาย
- นโยบาย
- ยอดนิยม
- เป็นไปได้
- โพสต์
- การปฏิบัติ
- นำเสนอ
- ส่วนตัว
- อาจ
- กระบวนการ
- กระบวนการ
- การผลิต
- การผลิต
- โปรไฟล์
- โครงการ
- คุณสมบัติ
- ให้
- ให้
- ให้
- หนังสือมอบฉันทะ
- การตีพิมพ์
- การดึง
- วัตถุประสงค์
- ผลัก
- ผลักดัน
- ผลักดัน
- ใส่
- หลาม
- ไฟฉาย
- พิสัย
- จริง
- เรียลไทม์
- แนะนำ
- แนะนำ
- บันทึก
- สะท้อน
- ภูมิภาค
- สัมพัทธ์
- วางใจ
- อาศัย
- ซากศพ
- เอาออก
- แทนที่
- กรุ
- การร้องขอ
- จำเป็นต้องใช้
- ความต้องการ
- การวิจัย
- คล้าย
- สำรอง
- ลิขสิทธิ์
- แหล่งข้อมูล
- คำตอบ
- รับผิดชอบ
- REST
- ส่งผลให้
- นำมาใช้ใหม่
- ข้าว
- บทบาท
- บทบาท
- วิ่ง
- วิ่ง
- ทำงาน
- เสียสละ
- เดียวกัน
- ลด
- ขนาด
- สถานการณ์
- สคริปต์
- SDK
- เห็น
- การเลือก
- การส่ง
- ระดับอาวุโส
- มีความละเอียดอ่อน
- แยก
- serverless
- เซิร์ฟเวอร์
- บริการ
- บริการ
- การให้บริการ
- ชุด
- การตั้งค่า
- การติดตั้ง
- รูปร่าง
- Share
- ที่ใช้ร่วมกัน
- น่า
- โชว์
- แสดงให้เห็นว่า
- แสดง
- แสดงให้เห็นว่า
- ด้าน
- คล้ายคลึงกัน
- เหมือนกับ
- ง่ายดาย
- หก
- ขนาด
- ขนาด
- มีขนาดเล็กกว่า
- So
- ทางออก
- โซลูชัน
- บาง
- ความเชี่ยวชาญ
- โดยเฉพาะ
- ที่ระบุไว้
- พูด
- มั่นคง
- กอง
- เริ่มต้น
- การเริ่มต้น
- startups
- ระบุ
- ขั้นตอน
- หยุด
- เก็บไว้
- ร้านค้า
- เสถียร
- การศึกษา
- ประสบความสำเร็จ
- อย่างเช่น
- การประชุมสุดยอด
- สนับสนุน
- ที่สนับสนุน
- แน่ใจ
- ระบบ
- ตาราง
- เอา
- นำ
- ใช้เวลา
- ทีม
- เทคโนโลยี
- ชั่วคราว
- tensorflow
- สถานีปลายทาง
- ทดสอบ
- การทดสอบ
- การทดสอบ
- เท็กซัส
- กว่า
- ที่
- พื้นที่
- ของพวกเขา
- พวกเขา
- แล้วก็
- ดังนั้น
- ล้อยางขัดเหล่านี้ติดตั้งบนแกน XNUMX (มม.) ผลิตภัณฑ์นี้ถูกผลิตในหลายรูปทรง และหลากหลายเบอร์ความแน่นหนาของปริมาณอนุภาคขัดของมัน จะทำให้ท่านได้รับประสิทธิภาพสูงในการขัดและการใช้งานที่ยาวนาน
- พวกเขา
- สิ่ง
- นี้
- เหล่านั้น
- ตลอด
- ปริมาณงาน
- ผูก
- เวลา
- ไปยัง
- ในวันนี้
- เครื่องมือ
- เครื่องมือ
- ด้านบน
- ไฟฉาย
- รวม
- ติดตาม
- การติดตาม
- แบบดั้งเดิม
- รถไฟ
- การฝึกอบรม
- หม้อแปลง
- ที่เชื่อถือ
- ลอง
- กลับ
- ฝาแฝด
- สอง
- ชนิด
- อูบุนตู
- ภายใต้
- พื้นฐาน
- มหาวิทยาลัย
- ยูนิกซ์
- เกินความจำเป็น
- เมื่อ
- us
- การใช้
- ใช้
- มือสอง
- ผู้ใช้งาน
- ผู้ใช้
- ใช้
- การใช้
- นำไปใช้
- ใช้ประโยชน์
- การใช้ประโยชน์
- ความคุ้มค่า
- ความคุ้มค่า
- รุ่น
- มาก
- มองเห็นได้
- วิสัยทัศน์
- ปริมาณ
- ต้องการ
- คือ
- ทาง..
- we
- เว็บ
- เว็บเซิร์ฟเวอร์
- บริการเว็บ
- ดี
- คือ
- เมื่อ
- ที่
- ทำไม
- อย่างกว้างขวาง
- จะ
- กับ
- ภายใน
- ไม่มี
- ผู้ปฏิบัติงาน
- แรงงาน
- จะ
- การเขียน
- เขียน
- คุณ
- ของคุณ
- ด้วยตัวคุณเอง
- ลมทะเล
- เป็นศูนย์