การเร่งความเร็วในการอนุมานโมเดลภาษาขนาดใหญ่: เทคนิคสำหรับการใช้งานที่มีประสิทธิภาพ

โมเดลภาษาขนาดใหญ่ (LLMs) เช่น GPT-4, LLaMA และ PaLM กำลังผลักดันขอบเขตของสิ่งที่เป็นไปได้กับการประมวลผลภาษาธรรมชาติ (NLP) อย่างไรก็ตาม การใช้งานโมเดลเหล่านี้ในproduction environments นำเสนอความท้าทายที่สำคัญในแง่ของความต้องการการประมวลผล ความใช้หน่วยความจำ ความหน่วง และต้นทุน เมื่อ LLMs ยังคงเติบโตขนาดใหญ่ขึ้นและสามารถทำได้มากขึ้น การเพิ่มประสิทธิภาพการอนุมานของพวกมันจึงมีความสำคัญต่อการประยุกต์ใช้จริง

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

มาเริ่มต้นด้วยการทำความเข้าใจว่าทำไมการอนุมาน LLMs จึงท้าทายกว่าโมเดล NLP แบบดั้งเดิม

ความท้าทายในการอนุมานของโมเดลภาษาขนาดใหญ่

ก่อนที่จะมี LLMs การประมวลผลภาษาธรรมชาติขึ้นอยู่กับโมเดลที่เล็กกว่าซึ่งมุ่งเน้นไปที่งานเฉพาะ เช่น การจำแนกประเภทข้อความ การตระหนักถึงชื่อของหน่วย และการวิเคราะห์ความรู้สึก แม้ว่าโมเดลเหล่านี้จะใช้การประมวลผลมาก แต่ก็สามารถใช้งานได้บนฮาร์ดแวร์ที่มีขนาดค่อนข้างน้อย และมีกระบวนการอนุมานที่ค่อนข้างตรงไปตรงมา

LLMs อีกฝ่ายหนึ่งแสดงถึงการเปลี่ยนแปลงของพาราไดม์ โมเดลเหล่านี้ได้รับการฝึกฝนบนเซตข้อมูลขนาดใหญ่โดยใช้พารามิเตอร์หลายพันล้าน ทำให้สามารถทำงานได้หลากหลายงานภาษาโดยมีความสามารถที่น่าประทับใจ อย่างไรก็ตาม ความสามารถนี้มาพร้อมกับต้นทุน – ความต้องการการประมวลผลที่เพิ่มขึ้นอย่างมากในช่วงการฝึกและการอนุมาน

หนึ่งในการท้าทายหลักคือลักษณะการสร้างข้อความแบบอัตโนมัติของ LLMs เพื่อสร้างข้อความที่เหมือนมนุษย์ โมเดลเหล่านี้คาดการณ์ตัวอักษร (คำหรือส่วนคำ) หนึ่งตัวต่อครั้ง โดยที่แต่ละตัวอักษรใหม่ขึ้นอยู่กับเอาต์พุตที่สร้างขึ้นก่อนหน้านี้ ความพึ่งพานี้ทำให้การขนานแบ่งไม่ได้และทำให้ความต้องการการประมวลผลเพิ่มขึ้นตามลำดับของความยาวของลำดับ

นอกจากนี้ LLMs มักต้องการลำดับอินพุตที่ยาว (คำแนะนำ) เพื่อสร้างบริบทที่จำเป็นสำหรับการสร้างข้อความที่มีคุณภาพสูง ความยาวอินพุตที่ยาวขึ้นต้องการหน่วยความจำมากขึ้นในการจัดเก็บสถานะและเมทริกซ์ความสนใจ ทำให้ทรัพยากรฮาร์ดแวร์หนักขึ้น

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

มาเริ่มด้วยกลยุทธ์หลักๆ ที่ออกแบบมาโดยเฉพาะสำหรับการเร่งความเร็วในการอนุมาน LLMs

เทคนิคความแม่นยำทางคณิตศาสตร์

From 32-Bit to 16-Bit Precision

หนึ่งทางเลือกในการเร่งความเร็วในการอนุมาน LLMs คือการใช้ความแม่นยำทางคณิตศาสตร์ที่ลดลงสำหรับน้ำหนักและกระบวนการของโมเดล แฟรมเวิร์กการเรียนรู้เชิงลึกสมัยใหม่ เช่น PyTorch และ TensorFlow โดยทั่วไปใช้ความแม่นยำจุดลอย 32 บิต (FP32) โดยค่าเริ่มต้น อย่างไรก็ตาม การวิจัยได้แสดงให้เห็นว่า LLMs สามารถรักษาความแม่นยำสูงได้แม้จะทำงานที่ความแม่นยำที่ต่ำกว่า เช่น 16 บิต (FP16), 8 บิตจำนวนเต็ม (INT8) หรือแม้กระทั่ง 4 บิตจำนวนเต็ม (INT4)

การลดความแม่นยำทางคณิตศาสตร์ให้ประโยชน์หลายประการ:

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

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

มีแนวทางหลักสองวิธีในการปรับขนาด LLMs:

การปรับขนาดหลังการฝึก (PTQ): ในวิธีนี้ LLM จะถูกฝึกโดยใช้ความแม่นยำ FP32 มาตรฐาน หลังจากการฝึก น้ำหนักของโมเดลจะถูกปรับขนาด (แปลง) เป็นรูปแบบความแม่นยำที่ต่ำกว่า เช่น INT8 หรือ INT4 PTQ เป็นวิธีที่ตรงไปตรงมาในการใช้งาน แต่อาจนำไปสู่การลดความแม่นยำที่มากขึ้น

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

สำหรับการใช้งานจริง คุณอาจใช้โมเดลที่ปรับขนาดล่วงหน้าซึ่งมีอยู่ในแพลตฟอร์ม เช่น Hugging Face ซึ่งจัดโฮสต์โมเดลที่ได้รับการปรับขนาดโดยใช้วิธีการปรับขนาดต่างๆ ตัวอย่างเช่น หากคุณต้องการโมเดลที่ปรับขนาดโดยใช้ Auto-GPTQ คุณสามารถโหลดได้โดยใช้ไลบรารีทรานส์ฟอร์เมอร์ของ Hugging Face นอกจากนี้ หากต้องการปรับขนาดโมเดล คุณสามารถใช้เครื่องมือ เช่น AutoGPTQ ซึ่งรวมเข้ากับไลบรารีเพื่อการบีบอัดโมเดลอย่างมีประสิทธิภาพ

ตัวอย่างการโหลดโมเดล LLaMA-2-7b ที่ปรับขนาดล่วงหน้าโดยใช้ไลบรารีทรานส์ฟอร์เมอร์ของ Hugging Face:

from transformers import AutoModelForCausalLM, AutoTokenizer

<p>model_id = "TheBloke/Llama-2-7b-Chat-GPTQ"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
And for custom quantization, one might follow these steps using the AutoGPTQ toolkit:</p>

<p>from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig</p>

<p>model_id = "llama-2-7b-original"
tokenizer = AutoTokenizer.from_pretrained(model_id)
quantization_config = GPTQConfig(bits=4, dataset="your-dataset", tokenizer=tokenizer)
model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=quantization_config)</p>

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

ควรสร้างสมดุลระหว่างขนาดโมเดล ความต้องการการประมวลผล และประสิทธิภาพเมื่อเลือกวิธีการปรับขนาดสำหรับกรณีการใช้งานของคุณ

อัลกอริทึมการดึงความสนใจแบบ Flash

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

อัลกอริทึม Flash Attention ซึ่งนำเสนอในกระดาษ Flash Attention เป็นวิธีการที่มีประสิทธิภาพและเป็นมิตรกับการขนานแบ่งมากกว่าในการดำเนินการดึงความสนใจ แทนที่จะคำนวณค่าดึงความสนใจใหม่สำหรับแต่ละโทเค็น Flash Attention จะแคชและนำค่าเมทริกซ์หลัก/ค่าใหม่มาใช้ซ้ำ ลดการคำนวณที่ซ้ำกัน

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

แม้ว่ารายละเอียดของ Flash Attention จะซับซ้อน แต่แนวคิดหลักคือการแบ่งการดำเนินการดึงความสนใจออกเป็นสองขั้นตอน:

1. การฝังตัวแบบ Prefix Sum: ขั้นตอนนี้คำนวณและแคชการฝังตัวหลัก/ค่าสำหรับโทเค็นอินพุตทั้งหมด ทำให้สามารถนำมาใช้ซ้ำได้อย่างมีประสิทธิภาพระหว่างการสร้างข้อความ
2. การดึงความสนใจแบบ Causal: การดำเนินการดึงความสนใจที่แท้จริง ซึ่งได้รับการปรับให้เหมาะสมเพื่อใช้ประโยชน์จากค่าหลัก/ค่าที่แคชไว้จากขั้นตอนแรก

ด้วยการแยกขั้นตอนเหล่านี้ Flash Attention สามารถใช้การดำเนินการขนานแบ่งที่มีประสิทธิภาพสูงของ GPU ได้ ทำให้สามารถเร่งการดำเนินการดึงความสนใจใน LLMs ได้อย่างมาก

นี่คือตัวอย่างการนำ Flash Attention ไปใช้กับ LLMs:

from transformers import AutoModelForCausalLM
import torch
from flash_attention import flash_attention

<p># โหลด LLM เช่น OctoCoder
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder")</p>

<p># โหลดพรอมต์ระบบที่ชี้นำโมเดลให้เป็นแอสซิสแตนต์การเขียนโค้ด
system_prompt = "..."</p>

<p># การเตรียมอินพุตที่ยาวขึ้นด้วยพรอมต์ระบบ
long_prompt = system_prompt + "คำถาม: โปรดเขียนฟังก์ชันใน Python ที่แปลงไบต์เป็นกิกะไบต์"</p>

<p># การเปลี่ยนโมเดลสำหรับการเพิ่มประสิทธิภาพ Flash Attention
model.to_bettertransformer()</p>

<p># การใช้งานโมเดลพร้อมกับ Flash Attention
start_time = time.time()
with torch.backends.cuda.sdp_kernel(enable_flash=True):
result = model.generate(long_prompt, max_new_tokens=60)
print(f"สร้างเสร็จใน {time.time() - start_time} วินาที.")

แม้ว่า Flash Attention จะให้การเพิ่มประสิทธิภาพที่น่าประทับใจ แต่ก็ทำงานภายในสถาปัตยกรรมทรานส์ฟอร์เมอร์ที่มีอยู่ เพื่อปลดปล่อยศักยภาพในการอนุมาน LLMs ที่เร่งความเร็วอย่างแท้จริง เราต้องสำรวจนวัตกรรมทางสถาปัตยกรรมที่ออกแบบมาโดยเฉพาะสำหรับงานนี้

การปรับขนาด LLMs

การปรับขนาด LLMs เป็นเทคนิคในการลดขนาดโมเดลโดยยังคงรักษาความสามารถไว้ โดยใช้การประมาณค่าความสำคัญของน้ำหนักตามมาตรฐานของเมทริกซ์เฮสเซียน์ ในการปรับขนาด น้ำหนักที่ไม่สำคัญจะถูกลบออก แล้วโมเดลจะถูกปรับให้เหมาะสมอีกครั้งเพื่อการกู้คืนความแม่นยำ LLM-Pruner มีคำสั่งสำหรับการปรับขนาดด้วยกลยุทธ์ต่างๆ

ตัวอย่างโค้ด Python ที่แสดงการใช้ LLM-Pruner สำหรับโมเดล LLaMa:

from transformers import AutoModelForSequenceClassification
from pruning import LLMPruner

<p># โหลดโมเดล LLaMa ที่ได้รับการฝึกฝนมาแล้ว
model = AutoModelForSequenceClassification.from_pretrained("llama-base")</p>

<p># ตั้งค่าปรับขนาดด้วยการกำหนดค่าที่ต้องการ
pruner = LLMPruner(
model,
pruning_ratio=0.25,
block_mlp_layers=(4, 30),
block_attention_layers=(4, 30),
pruner_type='taylor'
)</p>

<p># ทำการปรับขนาด
pruned_model = pruner.prune()</p>

<p># ปรับให้เหมาะสมโมเดลที่ปรับขนาด
pruned_model.fine_tune(training_data)

ตัวอย่างโค้ดนี้แสดงการโหลดโมเดล LLaMa ที่ได้รับการฝึกฝนมาแล้ว การตั้งค่าปรับขนาดด้วยการกำหนดค่าที่ต้องการ การทำการปรับขนาด และการปรับให้เหมาะสมโมเดลที่ปรับขนาด

นวัตกรรมทางสถาปัตยกรรมสำหรับการสร้างข้อความที่มีประสิทธิภาพ

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

นี่คือนวัตกรรมทางสถาปัตยกรรมหลักๆ ที่ช่วยให้การอนุมาน LLMs เร็วขึ้น:

Alibi: สถาปัตยกรรม Alibi ซึ่งถูกนำเสนอในกระดาษ PAL-Instruction แบ่งการสร้างแบบจำลองบริบทอินพุตยาวออกจากกระบวนการสร้างข้อความโดยตรง โดยใช้การแสดงถึงที่บีบอัดของบริบทอินพุต (alibi) เพื่อช่วยในการเริ่มต้นการสร้างข้อความ ลดความจำเป็นในการประมวลผลลำดับอินพุตทั้งหมดซ้ำๆ ระหว่างการสร้างข้อความแบบอัตโนมัติ

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

การดึงความสนใจแบบ Multi-Query (MQA): ในการดึงความสนใจแบบดั้งเดิม แต่ละโทเคนออกรายการจะดึงความสนใจจากทั้งลำดับอินพุต ซึ่งนำไปสู่การคำนวณที่ซ้ำกัน MQA เป็นการปฏิรูปการดึงความสนใจเพื่อแบ่งปันการคำนวณระหว่างโทเคนออกรายการหลายตัว ลดความซับซ้อนโดยรวม

Multiquery attention

การดึงความสนใจแบบ Grouped-Query-Attention (GQA): GQA ขยาย MQA โดยการแบ่งโทเคนออกรายการออกเป็นกลุ่มและคำนวณการดึงความสนใจร่วมกันสำหรับแต่ละกลุ่ม วิธีนี้ลดความต้องการการประมวลผลลงในขณะเดียวกันก็รักษาคุณภาพการสร้างข้อความที่สูงไว้

แม้ว่านวัตกรรมเหล่านี้ยังคงอยู่ในช่วงการวิจัยและพัฒนา แต่ก็ได้แสดงให้เห็นถึงการเพิ่มความเร็วที่น่าประทับใจสำหรับการอนุมาน LLMs โดยเฉพาะอย่างยิ่งเมื่อรวมกับเทคนิคอื่นๆ เช่น Flash Attention และการปรับขนาดความแม่นยำทางคณิตศาสตร์

การพิจารณาในการใช้งานจริง

นอกเหนือจากอัลกอริทึมและสถาปัตยกรรมหลักแล้ว ยังมีการพิจารณาหลายประการในการใช้งาน LLMs ในสภาพแวดล้อมการผลิต:

การเร่งความเร็วฮาร์ดแวร์: แม้ว่า CPU จะสามารถจัดการการอนุมาน LLMs ได้ แต่ GPU และตัวเร่งความเร็วอื่นๆ เช่น TPU ของ Google (GOOGL ) เป็นสิ่งจำเป็นสำหรับการบรรลุการรับส่งข้อมูลสูงและความหน่วงต่ำ การเลือกฮาร์ดแวร์ที่เหมาะสมและเพิ่มประสิทธิภาพการใช้หน่วยความจำจึงมีความสำคัญ

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

การซื้อขายระหว่างการปรับขนาดและคุณภาพ: ระดับการปรับขนาด (8 บิต, 4 บิต, ฯลฯ) จะส่งผลกระทบโดยตรงต่อความเร็วการอนุมานและความต้องการหน่วยความจำ แต่ยังจะส่งผลต่อคุณภาพเอาต์พุตด้วย การซื้อขายระหว่างการปรับขนาดและคุณภาพจึงต้องได้รับการประเมินอย่างรอบคอบสำหรับกรณีการใช้งานแต่ละรายการ

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

การแคชและรันไทม์ที่ได้รับการปรับให้เหมาะสม: รันไทม์เชิงลึกที่ได้รับการปรับให้เหมาะสม เช่น TensorRT ของ NVIDIA (NVDA ) และเฟรมเวิร์กที่ออกแบบมาเพื่อการให้บริการ LLMs (เช่น Composable Inference Suite ของ MosaicML) สามารถให้การเพิ่มประสิทธิภาพที่สำคัญผ่านเทคนิค เช่น การรวมตัวดำเนินการ การปรับให้เหมาะสมของเคอร์เนล และกลยุทธ์การแคชที่ชาญฉลาด

เส้นทางสู่การ_deploy LLMs ที่เหมาะสมมักเกี่ยวข้องกับการรวมเทคนิคหลายอย่างในขณะที่พิจารณาความต้องการเฉพาะของแอปพลิเคชันของคุณ ข้อจำกัดของโครงสร้างพื้นฐาน และเป้าหมายการแสดงผล

สรุป

เมื่อ LLMs ยังคงพัฒนาอย่างรวดเร็ว การเร่งความเร็วในการอนุมานของพวกมันจึงมีความสำคัญมากขึ้นสำหรับการใช้งานจริงและทำให้สามารถเข้าถึง AI ที่ทรงพลังเหล่านี้ได้กว้างขึ้น

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

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