แพลตฟอร์มการอนุมานของ Microsoft นำโมเดลภาษาขนาดใหญ่ 1 บิตมาใช้กับอุปกรณ์ระดับลोकัล

ในวันที่ 17 ตุลาคม 2024 Microsoft (MSFT ) ได้ประกาศ BitNet.cpp ซึ่งเป็นเฟรมเวิร์กการอนุมานที่ออกแบบมาเพื่อรันโมเดลภาษาขนาดใหญ่ 1 บิต (LLMs) BitNet.cpp เป็นความก้าวหน้าที่สำคัญในด้าน Gen AI โดยทำให้สามารถใช้โมเดลภาษาขนาดใหญ่ 1 บิตได้อย่างมีประสิทธิภาพบน CPU มาตรฐานโดยไม่ต้องใช้ GPU ที่มีราคาแพง การพัฒนานี้ทำให้สามารถเข้าถึงโมเดลภาษาขนาดใหญ่ได้กว้างขึ้น และเปิดโอกาสใหม่ๆ สำหรับการใช้งาน AI บนอุปกรณ์ระดับลोकัล

การทำความเข้าใจโมเดลภาษาขนาดใหญ่ 1 บิต

โมเดลภาษาขนาดใหญ่ (LLMs) มักต้องการทรัพยากรการคำนวณที่มีนัยสำคัญเนื่องจากการใช้ตัวเลขทศนิยมความแม่นยำสูง (โดยทั่วไปเป็น FP16 หรือ BF16) สำหรับน้ำหนักโมเดล ซึ่งทำให้การนำโมเดลภาษาขนาดใหญ่ไปใช้งานมีราคาแพงและใช้พลังงานมาก

โมเดลภาษาขนาดใหญ่ 1 บิตใช้เทคนิคการปรับขนาดที่รุนแรงเพื่อแสดงน้ำหนักโมเดลโดยใช้ค่าสามค่าเท่านั้น: -1, 0 และ 1 ดังนั้นจึงเรียกว่า “1.58 บิต” (เนื่องจากต้องใช้มากกว่า 1 บิตเล็กน้อยเพื่อเข้ารหัสสถานะสามสถานะ)

ระบบน้ำหนักเทอร์นารี

แนวคิด

การปรับขนาด 1 บิตใน BitNet.cpp เป็นระบบน้ำหนักเทอร์นารี BitNet ทำงานด้วยค่าที่เป็นไปได้สามค่าสำหรับแต่ละพารามิเตอร์:

• -1 (ลบ)
• 0 (เป็นกลาง)
• 1 (บวก)

สิ่งนี้ส่งผลให้ต้องการพื้นที่จัดเก็บประมาณ 1.58 บิตต่อน้ำหนัก ทำให้ชื่อ BitNet b1.58 การลดขนาดนี้ของความกว้างบิตของพารามิเตอร์นำไปสู่การลดความซับซ้อนของการคำนวณและความต้องการหน่วยความจำที่ลดลงอย่างมาก เนื่องจากการคูณทศนิยมส่วนใหญ่ถูกแทนที่ด้วยการบวกและการลบแบบง่าย

พื้นฐานทางคณิตศาสตร์

การปรับขนาด 1 บิตเกี่ยวข้องกับการแปลงน้ำหนักและแอคติเวชันให้เป็นตัวแทนเทอร์นารีโดยผ่านขั้นตอนต่อไปนี้:

1. การแปลงน้ำหนักเป็นไบนารี

การแปลงน้ำหนักเป็นไบนารี่เกี่ยวข้องกับการจัดศูนย์กลางน้ำหนักโดยใช้ค่าเฉลี่ย (α) ซึ่งส่งผลให้ได้น้ำหนักเทอร์นารี การแปลงนี้แสดงเป็นทางคณิตศาสตร์:

Wf​=Sign(W−α)

โดยที่:

• W คือน้ำหนักเดิม
• α ค่าค่าเฉลี่ยของน้ำหนัก
• Sign(x) คืนค่า +1 ถ้า x > 0 และ -1 ในกรณีอื่นๆ

2. การปรับขนาดแอคติเวชัน

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

x^e​=Quant(x)=Clip(γx×Qb​​,−Qb​+ϵ,Qb​−ϵ)

โดยที่:

• Qb = 2(b−1)2^{(b-1)}2(b−1) คือระดับการปรับขนาดสูงสุดสำหรับความกว้างบิต b
• γ ค่าค่าสัมบูรณ์สูงสุดของ x (แสดงเป็น ∣∣x∣∣∞​
• ε ค่าตัวเลขเล็กๆ ที่ป้องกันการเกิดอาการ 溢นตัวระหว่างการคำนวณ

3. การดำเนินการ BitLinear

ชั้น BitLinear แทนที่การคูณเมทริกซ์แบบดั้งเดิมด้วยการดำเนินการแบบง่าย:

y=Wf​×x^e​×(Qb​βγ​)

โดยที่:

• β คือปัจจัยสเกลที่ใช้เพื่อลดข้อผิดพลาดในการประมาณ
• γ สเกลแอคติเวชัน
• Q_b คือปัจจัยการปรับขนาด

การแปลงนี้ทำให้สามารถคำนวณได้อย่างมีประสิทธิภาพในขณะที่ยังคงรักษาความสามารถของโมเดลไว้

ผลกระทบต่อประสิทธิภาพ

ประสิทธิภาพด้านหน่วยความจำ

ระบบน้ำหนักเทอร์นารีมีผลกระทบอย่างมากต่อความต้องการหน่วยความจำ:

• โมเดลภาษาขนาดใหญ่แบบดั้งเดิม: 16 บิตต่อน้ำหนัก
• BitNet.cpp: 1.58 บิตต่อน้ำหนัก

การลดขนาดนี้ส่งผลให้ประหยัดหน่วยความจำได้ถึง 90% เมื่อเทียบกับโมเดล 16 บิตแบบดั้งเดิม ทำให้สามารถใช้โมเดลที่ใหญ่ขึ้นได้ภายในข้อจำกัดของฮาร์ดแวร์เดียวกัน

1. ความเร็วการอนุมาน: เร็วกว่าทั้ง CPU

ความเร็วการอนุมานแสดงเป็นจำนวนโทเค็นที่ประมวลผลต่อวินาที มีการสังเกตการณ์อย่างไร:

• บน Apple (AAPL ) M2 Ultra: BitNet.cpp สามารถเพิ่มความเร็วได้ถึง 5.07 เท่า สำหรับโมเดลขนาดใหญ่ (30B) เมื่อเทียบกับ Llama.cpp โดยมีจุดสูงสุด 593.43 โทเค็นต่อวินาที สำหรับโมเดล 125M ซึ่งเป็นการเพิ่มความเร็ว 1.37 เท่า สำหรับโมเดลขนาดใหญ่ เช่น 3.8B และ 7B BitNet.cpp ยังคงรักษาความเร็วไว้เหนือ 84.77 โทเค็นต่อวินาที แสดงให้เห็นถึงประสิทธิภาพที่ดีในหลายขนาด
• บน Intel (INTC ) i7-13700H: BitNet.cpp มีการปรับปรุงความเร็วที่น่าประทับใจยิ่งขึ้น โดยเฉพาะที่ขนาดโมเดล 7B ซึ่ง BitNet.cpp มีการเพิ่มความเร็ว 5.68 เท่า เมื่อเทียบกับ Llama.cpp สำหรับโมเดลขนาดเล็ก เช่น 125M มีการประมวลผล 389.08 โทเค็นต่อวินาที ซึ่งเร็วกว่า Llama.cpp ถึง 2.37 เท่า

2. ประสิทธิภาพด้านพลังงาน: เปลี่ยนเกมสำหรับอุปกรณ์ระดับลอก

กราฟที่ให้มาประกอบด้วยการเปรียบเทียบต้นทุนพลังงาน ซึ่งแสดงถึงการลดการใช้พลังงานที่สำคัญต่อโทเค็นที่ประมวลผล:

• บน Apple M2 Ultra: BitNet.cpp มีการประหยัดพลังงานที่สำคัญ สำหรับโมเดล 700M มีการใช้พลังงาน 55.4% น้อยกว่า ต่อโทเค็น เมื่อเทียบกับ Llama.cpp โดยลดลงจาก 0.314 ถึง 0.140 แนวโน้มนี้ยังคงดำเนินต่อไปสำหรับโมเดลขนาดใหญ่ โดยที่โมเดล 70B แสดงถึงการลดการใช้พลังงาน 70.0%
• บน Intel i7-13700H: BitNet.cpp มีการประหยัดพลังงาน 71.9% สำหรับโมเดล 700M โดยลดการใช้พลังงานจาก 1.367 ถึง 0.384 แม้ว่าข้อมูลการใช้พลังงานสำหรับโมเดล 70B ใน Llama.cpp จะไม่มีให้ BitNet.cpp ยังคงแสดงถึงประสิทธิภาพด้านพลังงานที่ดี โดยมีการใช้พลังงานที่ 17.33 สำหรับโมเดล 70B

3. การข้ามมาตรฐานความเร็วการอ่านของมนุษย์

ข้อมูลที่น่าสนใจจากกราฟเหล่านี้คือการอ้างอิงถึง ความเร็วการอ่านของมนุษย์ ซึ่งกำหนดไว้ที่ 5-7 โทเค็นต่อวินาที เส้นสีแดงแสดงให้เห็นว่าทั้งสองการนำไปใช้ โดยเฉพาะ BitNet.cpp สามารถที่จะเกินความเร็วการอ่านของมนุษย์ได้อย่างสบายๆ สำหรับโมเดลขนาดใหญ่:

• บน Apple M2 Ultra BitNet.cpp เกินความเร็วการอ่านของมนุษย์สำหรับทุกขนาดโมเดล โดยมีความเร็วต่ำสุดอยู่ที่ 8.67 โทเค็นต่อวินาที สำหรับโมเดล 70B
• บน Intel i7-13700H โมเดล 100B ยังคงสามารถทำได้ 1.70 โทเค็นต่อวินาที ซึ่งเกือบจะถึงช่วงต่ำสุดของความเร็วการอ่านของมนุษย์ ในขณะที่โมเดลที่เล็กกว่านั้นเกินมาตรฐานนี้

ข้อพิจารณาในการฝึกอบรม

ตัวประมาณการแบบตรงไปตรงมา (STE)

เนื่องจากการปรับขนาด 1 บิตทำให้เกิดฟังก์ชันที่ไม่สามารถแยกแยะได้ การฝึกอบรมจึงเกี่ยวข้องกับเทคนิคพิเศษที่เรียกว่า ตัวประมาณการแบบตรงไปตรงมา (STE) ในแนวทางนี้ แกรเดียนต์จะไหลผ่านจุดไม่สามารถแยกแยะได้โดยไม่มีการเปลี่ยนแปลง นี่คือการนำไปใช้แบบง่ายๆ ใน Python:

class StraightThroughEstimator(Function):
@staticmethod
def forward(ctx, input):
return input.sign()

@staticmethod
def backward(ctx, grad_output):
return grad_output

การฝึกอบรมด้วยความแม่นยำผสม

เพื่อรักษาเสถียรภาพระหว่างการฝึกอบรม ความแม่นยำผสม จะถูกนำมาใช้:

• น้ำหนักและแอคติเวชัน: ปรับขนาดเป็น 1 บิต
• แกรเดียนต์และสถานะของออปติมายเซอร์: เก็บไว้ในความแม่นยำที่สูงกว่า
• น้ำหนักลาตัน: รักษาไว้ในความแม่นยำสูงเพื่ออำนวยความสะดวกในการอัปเดตที่แม่นยำระหว่างการฝึกอบรม

กลยุทธ์การเรียนรู้อัตราที่ใหญ่

ความท้าทายที่ไม่เหมือนใครสำหรับโมเดล 1 บิตคือการปรับเปลี่ยนเล็กๆ อาจไม่ส่งผลต่อน้ำหนักที่แปลงเป็นไบนารี เพื่อแก้ไขปัญหานี้ อัตราการเรียนรู้จะถูกเพิ่มขึ้นเพื่อให้แน่ใจว่าการ сходของโมเดลจะเร็วขึ้นและดีขึ้นเมื่อเทียบกับแนวทางแบบดั้งเดิม

การปรับขนาดและปกติแบบกลุ่ม

BitNet.cpp นำ การปรับขนาดและปกติแบบกลุ่ม มาใช้เพื่อเพิ่มความสามารถในการขนานกันของโมเดล แทนที่จะคำนวณพารามิเตอร์สำหรับเมทริกซ์น้ำหนักทั้งหมด BitNet จะแบ่งน้ำหนักและแอคติเวชันออกเป็นกลุ่มหลายกลุ่ม (G)

การแบ่งกลุ่มนี้ทำให้สามารถประมวลผลขนานได้อย่างมีประสิทธิภาพโดยไม่ต้องมีการสื่อสารระหว่างกลุ่ม ทำให้สามารถฝึกอบรมและอนุมานโมเดลขนาดใหญ่ได้

หมายเหตุการนำไปใช้และการปรับให้เหมาะสม

การปรับให้เหมาะสมสำหรับ CPU

BitNet.cpp ใช้การปรับให้เหมาะสมระดับต่ำหลายอย่างเพื่อให้ได้ประสิทธิภาพ CPU สูงสุด:

• การดำเนินการเวกเตอร์: ใช้คำสั่ง SIMD เพื่อจัดการบิตอย่างมีประสิทธิภาพ
• การเข้าถึงหน่วยความจำที่เป็นมิตรกับแคช: จัดโครงสร้างข้อมูลเพื่อลดการพลาดแคช
• การประมวลผลขนาน: แบ่งงานให้กับหลายแกน CPU อย่างมีประสิทธิภาพ

โมเดลที่รองรับ

การเปิดตัวครั้งแรกของ BitNet.cpp รองรับ โมเดลภาษาขนาดใหญ่ 1 บิต ต่อไปนี้ที่มีอยู่ใน Hugging Face:

• bitnet_b1_58-large (0.7B พารามิเตอร์)
• bitnet_b1_58-3B (3.3B พารามิเตอร์)
• Llama3-8B-1.58-100B-tokens (8.0B พารามิเตอร์)

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

คู่มือการติดตั้ง

เพื่อเริ่มต้นใช้งาน BitNet.cpp ให้ทำตามขั้นตอนต่อไปนี้:

ข้อกำหนดเบื้องต้น

1. Python >= 3.9
2. CMake >= 3.22
3. Clang >= 18
4. Conda (แนะนำอย่างยิ่ง)

ขั้นตอนการติดตั้งแบบทีละขั้นตอน

1. การโคลนรีพอสิทอรี:
   git clone --recursive https://github.com/microsoft/BitNet.git

   
cd BitNet

2. การติดตั้งพื้นฐาน:
   # สร้างสภาพแวดล้อม Conda ใหม่ (แนะนำ)
conda create -n bitnet-cpp python=3.9
conda activate bitnet-cpp

pip install -r requirements.txt
3. การสร้างและเตรียมโครงการ: คุณสามารถดาวน์โหลดโมเดลโดยตรงจาก Hugging Face และแปลงเป็นรูปแบบปรับขนาด:
   python setup_env.py --hf-repo HF1BitLLM/Llama3-8B-1.58-100B-tokens -q i2_s


   หรือดาวน์โหลดและแปลงโมเดลด้วยตนเอง:

   huggingface-cli download HF1BitLLM/Llama3-8B-1.58-100B-tokens --local-dir models/Llama3-8B-1.58-100B-tokens

   
python setup_env.py -md models/Llama3-8B-1.58-100B-tokens -q i2_s


การรันการอนุมานด้วย BitNet.cpp

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

คำอธิบาย:

• -m ระบุเส้นทางไฟล์โมเดล
• -p ระบุข้อความพรอมต์
• -n ตั้งค่าจำนวนโทเค็นที่จะคาดการณ์
• -temp ปรับเปลี่ยนความสุ่มในการสุ่มตัวอย่างระหว่างการอนุมาน

ตัวอย่างการออก:

รายละเอียดทางเทคนิคของ BitNet.cpp

ชั้น BitLinear

BitNet.cpp นำเสนอสถาปัตยกรรม Transformer ที่ได้รับการปรับเปลี่ยน โดยแทนที่การคูณเมทริกซ์แบบดั้งเดิมด้วยการดำเนินการ BitLinear การเปลี่ยนแปลงนี้จัดศูนย์กลางน้ำหนักไว้ที่ศูนย์ ก่อนการปรับขนาดและปรับขนาดเพื่อลดข้อผิดพลาดในการประมาณ

ผลกระทบต่ออุตสาหกรรม

BitNet.cpp อาจมีผลกระทบอย่างกว้างขวางต่อการนำโมเดลภาษาขนาดใหญ่ไปใช้:

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

ความท้าทายและทิศทางในอนาคต

แม้ว่าโมเดลภาษาขนาดใหญ่ 1 บิตจะมีศักยภาพ แต่ก็ยังมีความท้าทายที่ต้องเผชิญ เช่น การพัฒนาโมเดลที่แข็งแกร่งสำหรับงานต่างๆ การปรับฮาร์ดแวร์ให้เหมาะสมสำหรับการคำนวณ 1 บิต และการสนับสนุนให้นักพัฒนานำแนวทางนี้ไปใช้ นอกจากนี้ การสำรวจการปรับขนาด 1 บิตสำหรับงานที่ไม่ใช่ภาษา เช่น การมองเห็นของเครื่องจักรหรืองานเสียง ยังเป็นทิศทางที่น่าสนใจสำหรับการวิจัยในอนาคต

สรุป

การเปิดตัว BitNet.cpp ของ Microsoft ถือเป็นความก้าวหน้าที่สำคัญ โดยการทำให้การอนุมาน 1 บิตมีประสิทธิภาพบน CPU มาตรฐาน BitNet.cpp ช่วยสร้างความสามารถในการเข้าถึงและความยั่งยืนของ AI โดยสร้างเวทีสำหรับโมเดลภาษาขนาดใหญ่ที่มีความสามารถในการพกพาและคุ้มต้นทุนมากขึ้น ซึ่งจะผลักดันสิ่งที่เป็นไปได้ในด้าน AI บนอุปกรณ์ระดับลอก