swiftLLM

SwiftLLM

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

ระบบอนุมาน LLM ขนาดเล็กแต่ทรงพลังซึ่งออกแบบมาเพื่อวัตถุประสงค์ในการค้นคว้าโดยเฉพาะ

ประสิทธิภาพเทียบเท่า vLLM โดยมีโค้ดเพียง 2,000 บรรทัด (2% ของ vLLM)

ทำไมต้อง SwiftLLM

มีเฟรมเวิร์กโอเพ่นซอร์สมากมายสำหรับการให้บริการ LLM รวมถึง HuggingFace Transformers, vLLM, LightLLM, DistServe และ DeepSpeed-MII ทำไมต้อง SwiftLLM?

เหตุผลก็คือ กรอบการทำงานเหล่านั้นได้รับการปรับแต่งสำหรับ การผลิต แทนที่จะ ค้นคว้าข้อมูล พวกเขามาพร้อมกับคุณสมบัติมากมาย เช่น การรองรับโมเดลมากกว่า 100 แบบ, การรองรับแบบฮาร์ดเวิร์ดต่างๆ, LoRA, การหาปริมาณ, มัลติโมดัล, การแคชคำนำหน้า, การค้นหาบีม และอื่นๆ แม้ว่าจะเป็นโซลูชันครบวงจรสำหรับการผลิต แต่ฐานโค้ดก็ใหญ่และซับซ้อนเกินกว่าจะเข้าใจและแก้ไขได้ (เช่น vLLM มีโค้ดมากกว่า 100,000 บรรทัด) ทำให้ยากต่อการใช้เพื่อการค้นคว้า นอกจากนี้ภาระทางประวัติศาสตร์ของพวกเขาก็เป็นปัญหาเช่นกัน

SwiftLLM ได้รับการออกแบบให้เป็นระบบอนุมาน LLM ขนาดเล็กแต่ทรงพลัง ซึ่งออกแบบมาเพื่อ วัตถุประสงค์ในการค้นคว้าโดย เฉพาะ "จิ๋ว" หมายความว่าจะเก็บเฉพาะฟีเจอร์ที่จำเป็นสำหรับการค้นคว้าเท่านั้น "ทรงพลัง" หมายความว่าไม่มีการลดทอนประสิทธิภาพ และสุดท้าย "รวดเร็ว" หมายความว่าง่ายต่อการเข้าใจและแก้ไข ในขณะที่รองรับคุณสมบัติพื้นฐาน (ดูรายการด้านล่าง) และความสามารถในการบรรลุประสิทธิภาพที่เทียบเท่ากับ vLLM ฐานโค้ดของ SwiftLLM นั้นมีโค้ดน้อยกว่า 2,000 บรรทัด (~ 2% ของ vLLM) ซึ่งเขียนด้วย Python และ OpenAI Triton (DSL สำหรับการเขียน เคอร์เนล CUDA) ทำให้ง่ายต่อการอ่าน แก้ไข ดีบัก ทดสอบ ขยาย และสามารถรวมเข้ากับแนวคิดการวิจัยที่แปลกใหม่และยอดเยี่ยมของคุณได้อย่างง่ายดาย

รายการคุณสมบัติ

ปัจจุบัน SwiftLLM รองรับคุณสมบัติดังต่อไปนี้:

• การกำหนดเวลาซ้ำและการเลือกแบทช์ (เสนอใน Orca)
• PagedAttenton (เสนอใน vLLM กระดาษ)
• รุ่น LLaMA / LLaMA2 / LLaMA3 (ลิงก์) และรุ่นต่างๆ
• การเติมและถอดรหัส Piggybacking ล่วงหน้า (เสนอในภาษาสราฐี)
• ความสนใจแบบแฟลช (เสนอใน FlashAttention และ FlashAttention-2)
• Paged Attention v2 (เรียกอีกอย่างว่า Flash-Decoding เสนอไว้ที่นี่)

และเราวางแผนที่จะเพิ่มการรองรับฟีเจอร์ต่อไปนี้ในอนาคต:

• ความขนานของเทนเซอร์และความขนานของไปป์ไลน์

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

• การหาปริมาณ
• โลรา
• ต่อเนื่องหลายรูปแบบ
• โมเดลที่ไม่เป็นไปตามสถาปัตยกรรมของ LLaMA
• วิธีการสุ่มตัวอย่างอื่นที่ไม่ใช่การสุ่มตัวอย่างโลภ
• ฮาร์ดแวร์รองรับนอกเหนือจาก NVIDIA GPU (แต่ควรโยกย้ายไปยังฮาร์ดแวร์อื่นได้ง่ายตราบใดที่ OpenAI Triton รองรับ)

โปรดจำไว้ว่า SwiftLLM ไม่ใช่โซลูชันแบบครบวงจรสำหรับการผลิต ขอแนะนำให้คิดว่ามันเป็น "รากฐาน" สำหรับโครงการวิจัยของคุณ และคุณอาจต้องใช้คุณสมบัติบางอย่างด้วยตัวเอง เราขอแนะนำให้คุณ นักวิจัยที่รัก อ่านโค้ด ทำความเข้าใจ แก้ไข และขยายให้เหมาะกับความต้องการในการวิจัยของคุณ

สถาปัตยกรรม

สถาปัตยกรรมของ SwiftLLM สามารถแบ่งออกเป็นสองส่วนหลัก: ระนาบควบคุม และ ระนาบข้อมูล

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

รหัสสำหรับระนาบควบคุมอยู่ในไดเร็กทอรี swiftllm/server รวมถึงส่วนประกอบต่างๆ เช่น Engine , Scheduler , เซิร์ฟเวอร์ API และ TokenizationEngine โค้ดสำหรับระนาบข้อมูลอยู่ในไดเร็กทอรี swiftllm/worker รวมถึงคำอธิบายของกราฟการคำนวณ (ใน swiftllm/worker/model.py ) การใช้งานเลเยอร์ในโมเดล (ใน swiftllm/layers ) และเคอร์เนล OpenAI Triton ( คุณสามารถจินตนาการว่า "เคอร์เนล" เป็นฟังก์ชันที่ทำงานบน GPU) (ใน swiftllm/kernels )

ลองใช้เซิร์ฟเวอร์ API ของเล่น (อยู่ใน swiftllm/server/api_server.py ) เป็นตัวอย่าง:

• เมื่อเปิดตัว จะใช้ EngineConfig เพื่อสร้าง Engine
• หลังจากนั้น เอ็นจิ้นจะเริ่มต้นได้ผ่าน Engine.initialize โดยที่มันสร้าง Scheduler , TokenizationEngine และชุดของผู้ปฏิบัติงาน (ปัจจุบันมีเพียงอันเดียวเนื่องจาก Tensor Parallelism ไม่ได้รับการสนับสนุน) จากนั้นจะสั่งให้ผู้ปฏิบัติงานดำเนินการ profile_num_blocks เพื่อคำนวณจำนวนบล็อก GPU หลังจากนั้นกลไกจะสั่งให้ผู้ปฏิบัติงานทั้งหมดจัดสรรแคช KV และการสลับ KV
• สุดท้าย ลูปเหตุการณ์จะถูกเปิดใช้งานผ่าน Engine.start_all_event_loops ในแต่ละขั้นตอนของลูป กลไกจะสอบถามตัวกำหนดเวลาสำหรับคำขอชุดถัดไปที่จะคำนวณ สั่งให้ผู้ปฏิบัติงานทำการสลับเข้า/ออก จากนั้นจึงส่งแบทช์ไปยังผู้ปฏิบัติงานเพื่อคำนวณ
• เซิร์ฟเวอร์ API รับฟังคำขอของผู้ใช้และโต้ตอบกับเอ็นจิ้นเพื่อตอบสนองคำขอเหล่านั้น

ขณะนี้ระนาบควบคุม ( Engine ) และระนาบข้อมูล ( LlamaModel ) อยู่บนโหนดเดียวกัน หลังจากใช้งาน Tensor Parallelism / Pipeline Parallelism แล้ว Data Plane อาจถูกกระจายไปยังหลายโหนด

วิธีใช้

เรานำเสนอสองวิธีในการใช้ SwiftLLM: การใช้ทั้งระนาบควบคุมและระนาบข้อมูล หรือใช้เฉพาะระนาบข้อมูล

หากแนวคิดของคุณเรียบง่ายหรือหรูหราพอที่จะรวมเข้ากับ Control Plane ที่มีอยู่ได้อย่างราบรื่น คุณสามารถใช้ทั้ง Control Plane และ Data Plane ได้ ในอีกกรณีหนึ่ง หากคุณต้องการใช้ IDE ที่ยอดเยี่ยม คุณสามารถใช้ประโยชน์จาก Data Plane และใช้ Control Plane ใหม่ได้ด้วยตัวเองเท่านั้น

สร้างและเรียกใช้

ขั้นแรกมาตั้งค่าสภาพแวดล้อมกันก่อน:

• คุณอาจเริ่มต้นจากสภาพแวดล้อม conda ที่สะอาดด้วย Python >= 3.9 หรือใช้สภาพแวดล้อมที่มีอยู่ อย่าลืมเปิดใช้งานสภาพแวดล้อม conda หากคุณใช้งานอยู่
• ติดตั้ง PyTorch ใส่ใจในการเลือกเวอร์ชันที่ถูกต้องตามฮาร์ดแวร์ของคุณ
• ติดตั้ง packaging ผ่าน pip install packaging

จากนั้นการติดตั้งก็มาถึง:

• โคลน repo นี้ผ่าน git clone https://github.com/interestingLSY/swiftLLM.git
• cd ลงใน repo ( cd swiftLLM ) และติดตั้งการอ้างอิงอื่น ๆ ผ่าน pip install -r requirements.txt
• PyTorch อาจติดตั้ง OpenAI Triton เวอร์ชันเสถียรให้กับคุณ หากคุณต้องการใช้เวอร์ชันกลางคืนเพื่อประสิทธิภาพที่ล้ำหน้าแต่อาจมีปัญหาเกิดขึ้น คุณสามารถถอนการติดตั้งและติดตั้งเวอร์ชันกลางคืนได้
• เรียกใช้ pip install -e . เพื่อติดตั้ง SwiftLLM ลงในสภาพแวดล้อมของคุณ
• ติดตั้ง C-bindings บางส่วนผ่าน pip install -e csrc

นี่คือตัวอย่างบางส่วน:

• ปัจจุบัน SwiftLLM ไม่รองรับการดาวน์โหลดตุ้มน้ำหนักจาก HuggingFace โดยอัตโนมัติ คุณอาจต้องโคลนหรือดาวน์โหลดตุ้มน้ำหนักโมเดลจาก HuggingFace ก่อน รองรับทั้งรูปแบบ .bin และ .safetensors สมมติว่าน้ำหนักโมเดลของคุณถูกเก็บไว้ที่ /data/to/weight/
• สำหรับตัวอย่างการให้บริการแบบออฟไลน์ คุณสามารถลองใช้ python3 examples/offline.py --model-path /data/to/weight ตัวอย่างนี้ใช้ระนาบข้อมูลเท่านั้น หากคุณวางแผนที่จะใช้ SwiftLLM โดยไม่มี Control Plane นี่เป็นจุดเริ่มต้นที่ดี
• สำหรับตัวอย่างการให้บริการออนไลน์ที่ใช้ Engine คุณสามารถลองใช้ python3 examples/online.py --model-path /data/to/weight นี่เป็นตัวอย่างที่ดีหากคุณวางแผนที่จะใช้ทั้งระนาบควบคุมและระนาบข้อมูล
• สำหรับตัวอย่างที่ซับซ้อนยิ่งขึ้น คุณสามารถอ้างถึง swiftllm/server/api_server.py เปิดตัวเซิร์ฟเวอร์ API และจัดเตรียมอินเทอร์เฟซที่คล้ายกับ vLLM สำหรับการให้บริการออนไลน์

ผลงาน

แม้จะตัวเล็ก (ตัวเล็กก็น่ารักได้เช่นกัน!) SwiftLLM ก็ไม่ประนีประนอมกับประสิทธิภาพ เราได้ประเมิน SwiftLLM ในหลายสถานการณ์ และแสดงให้เห็นว่า SwiftLLM สามารถบรรลุประสิทธิภาพที่เทียบเท่าหรือดีกว่าเมื่อเปรียบเทียบกับ vLLM

การดำเนินการไปข้างหน้าครั้งเดียว

สถานการณ์แรกคือ "การดำเนินการส่งต่อครั้งเดียว" โดยที่เราป้อนโมเดลด้วยชุดอินพุต และปล่อยให้มันสร้างโทเค็นเอาต์พุตหนึ่งโทเค็น (เทียบเท่ากับการดำเนินการ "ส่งต่อ" หนึ่งรายการ) นี่คือการดำเนินการพื้นฐานของการอนุมาน LLM (ทั้งออนไลน์และออฟไลน์) ดังนั้นประสิทธิภาพจึงเป็นสิ่งสำคัญ

ที่นี่เราใช้รุ่น LLaMA-3 7B พร้อม GPU NVIDIA A100 80G PCIE / RTX 4090 ภายใต้ความแม่นยำ FP16 ผลลัพธ์แสดงไว้ด้านล่าง (ต่ำกว่าดีกว่า):

จะเห็นได้ว่า SwiftLLM สามารถบรรลุประสิทธิภาพที่เทียบเท่า (หรือมีประสิทธิภาพเหนือกว่า) กับ vLLM ภายใต้การตั้งค่าเดียวกัน

การให้บริการออนไลน์

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

ที่นี่เราใช้ชุดข้อมูล ShareGPT เพื่อสุ่มตัวอย่างข้อความแจ้ง และใช้กระบวนการปัวซงกับ lambda ที่แตกต่างกันเพื่อจำลองอัตราการมาถึงของคำขอที่แตกต่างกัน ผลลัพธ์แสดงไว้ด้านล่าง (ต่ำกว่าดีกว่า):

จะเห็นได้ว่าบน A100 80G PCIE นั้น SwiftLLM สามารถบรรลุประสิทธิภาพที่เทียบเท่ากับ vLLM ในขณะที่ RTX 4090 นั้น SwiftLLM มีประสิทธิภาพเหนือกว่า vLLM อย่างมาก (สาเหตุหลักมาจากระนาบการควบคุมของเรามีค่าใช้จ่ายที่ต่ำกว่า)