พลังของ Rerankers และการค้นหาที่มีหลายขั้นตอนสำหรับการสร้างเนื้อหาที่เพิ่มขึ้นโดยการค้นหา

เมื่อพูดถึงการประมวลผลภาษาธรรมชาติ (NLP) และการค้นหาข้อมูล ความสามารถในการค้นหาข้อมูลที่เกี่ยวข้องอย่างมีประสิทธิภาพและแม่นยำเป็นสิ่งสำคัญ เมื่อภาคส่วนนี้ต่อเนื่องไป การพัฒนาวิธีการและเทคนิคใหม่ๆ เพื่อปรับปรุงประสิทธิภาพของระบบการค้นหาข้อมูล โดยเฉพาะอย่างยิ่งในบริบทของ การสร้างเนื้อหาที่เพิ่มขึ้นโดยการค้นหา (RAG) เทคนิคหนึ่งที่เรียกว่าการค้นหาที่มีหลายขั้นตอนพร้อมกับ rerankers ได้ปรากฏขึ้นเป็นวิธีแก้ปัญหาที่มีประสิทธิภาพเพื่อแก้ไขข้อจำกัดที่ซ่อนอยู่ของวิธีการค้นหาทั่วไป

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

การทำความเข้าใจการสร้างเนื้อหาที่เพิ่มขึ้นโดยการค้นหา (RAG)

ก่อนที่จะพูดถึงรายละเอียดของการค้นหาที่มีหลายขั้นตอนและ rerankers มาทำความเข้าใจกับแนวคิดของการสร้างเนื้อหาที่เพิ่มขึ้นโดยการค้นหา (RAG) กันก่อน RAG เป็นเทคนิคที่ขยายความสามารถและความรู้ของโมเดลภาษาขนาดใหญ่ (LLM) โดยการให้พวกมันเข้าถึงแหล่งข้อมูลภายนอก เช่น ฐานข้อมูลหรือคอลเลกชันเอกสาร อ้างอิงเพิ่มเติมจากบทความ “การดูอย่างลึกเกี่ยวกับการสร้างเนื้อหาที่เพิ่มขึ้นโดยการค้นหาใน LLM“

กระบวนการ RAG ทั่วไปประกอบด้วยขั้นตอนต่อไปนี้:

1. คำถาม: ผู้ใช้ถามคำถามหรือให้คำแนะนำแก่ระบบ
2. การค้นหา: ระบบค้นหาในฐานข้อมูลเวกเตอร์หรือคอลเลกชันเอกสารเพื่อหาข้อมูลที่เกี่ยวข้องกับคำถามของผู้ใช้
3. การเพิ่มข้อมูล: ข้อมูลที่ค้นหามาได้รวมกับคำถามหรือคำแนะนำของผู้ใช้เดิม
4. การสร้าง: โมเดลภาษาประมวลผลข้อมูลที่เพิ่มขึ้นและสร้างคำตอบ โดยใช้ข้อมูลภายนอกเพื่อปรับปรุงความแม่นยำและความครอบคลุมของผลลัพธ์

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

ความจำเป็นของการค้นหาที่มีหลายขั้นตอนและ rerankers

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

เพื่อแก้ไขความท้าทายนี้ นักวิจัยและผู้ปฏิบัติงานได้หันมาใช้การค้นหาที่มีหลายขั้นตอนพร้อมกับ rerankers วิธีนี้ประกอบด้วยกระบวนการที่มีสองขั้นตอน:

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

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

ประโยชน์ของการค้นหาที่มีหลายขั้นตอนและ rerankers

การนำการค้นหาที่มีหลายขั้นตอนพร้อมกับ rerankers ไปใช้ให้ได้ผลลัพธ์ที่ดีหลายประการในบริบทของระบบ RAG:

1. ความแม่นยำที่ดีขึ้น: โดยการเรียงลำดับเอกสารที่ค้นหามาได้ใหม่และนำเอกสารที่เกี่ยวข้องมากที่สุดมาไว้ด้านหน้า ระบบสามารถให้ข้อมูลที่แม่นยำและถูกต้องมากขึ้นแก่โมเดลภาษา ส่งผลให้ได้คำตอบที่มีคุณภาพสูงขึ้น
2. การลดปัญหาออกนอกโดเมน: โมเดลการเรียงลำดับใหม่สามารถฝึกฝนได้โดยใช้ข้อมูลเฉพาะโดเมน ซึ่งช่วยลดปัญหา “ออกนอกโดเมน” และปรับปรุงความเกี่ยวข้องของเอกสารที่ค้นหามาได้ในโดเมนเฉพาะ
3. การปรับขนาด: วิธีการที่มีหลายขั้นตอนช่วยให้สามารถปรับขนาดได้ดีโดยใช้วิธีการค้นหาที่เร็วและเบาในขั้นตอนแรก และสำรองขั้นตอนการเรียงลำดับใหม่ที่ต้องใช้การประมวลผลมากขึ้นสำหรับเซตเอกสารที่เล็กกว่า
4. ความยืดหยุ่น: โมเดลการเรียงลำดับใหม่สามารถถูกเปลี่ยนหรืออัปเดตได้อย่างอิสระจากวิธีการค้นหาตามขั้นตอนแรก ทำให้ระบบมีความยืดหยุ่นและสามารถปรับตัวให้เข้ากับความต้องการที่เปลี่ยนแปลงได้

ColBERT: การโต้ตอบที่มีประสิทธิภาพและประสิทธิผลในระยะหลัง

หนึ่งในโมเดลที่โดดเด่นในด้านการเรียงลำดับใหม่คือ ColBERT (การโต้ตอบที่มีบริบทในระยะหลังบน BERT) ColBERT เป็นโมเดลการเรียงลำดับเอกสารที่ใช้ความสามารถในการเข้าใจภาษาลึกซึ้งของ BERT และแนะนำกลไกโต้ตอบใหม่ที่เรียกว่า “การโต้ตอบในระยะหลัง”

ColBERT: การค้นหาสลักลูกบาศก์ที่มีประสิทธิภาพและประสิทธิผลผ่านการโต้ตอบที่มีบริบทในระยะหลังบน BERT

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

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

การนำการค้นหาที่มีหลายขั้นตอนพร้อมกับ rerankers ไปใช้

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

การเตรียมสภาพแวดล้อม

ก่อนที่จะเริ่มเขียนโค้ด เราต้องเตรียมสภาพแวดล้อมการพัฒนา เราจะใช้ Python และไลบรารี NLP ที่เป็นที่นิยมหลายตัว รวมถึง Hugging Face Transformers, Sentence Transformers และ LanceDB

# ติดตั้งไลบรารีที่จำเป็น
!pip install datasets huggingface_hub sentence_transformers lancedb

การเตรียมข้อมูล

เพื่อการแสดงตัวอย่าง เราจะใช้เซตข้อมูล “ai-arxiv-chunked” จาก Hugging Face Datasets ซึ่งมีเอกสารมากกว่า 400 ฉบับจาก ArXiv ในหัวข้อการเรียนรู้ของเครื่อง, การประมวลผลภาษาธรรมชาติ และโมเดลภาษาขนาดใหญ่

from datasets import load_dataset

<p>dataset = load_dataset(&quot;jamescalam/ai-arxiv-chunked&quot;, split=&quot;train&quot;)</p>

&amp;lt;pre&amp;gt;

ต่อไป เราจะประมวลผลข้อมูลและแบ่งออกเป็นชิ้นเล็กๆ เพื่ออำนวยความสะดวกในการค้นหาและประมวลผล

from transformers import AutoTokenizer

<p>tokenizer = AutoTokenizer.from_pretrained(&quot;bert-base-uncased&quot;)</p>

<p>def chunk_text(text, chunk_size=512, overlap=64):
tokens = tokenizer.encode(text, return_tensors=&quot;pt&quot;, truncation=True)
chunks = tokens.split(chunk_size - overlap)
texts = [tokenizer.decode(chunk) for chunk in chunks]
return texts</p>

<p>chunked_data = []
for doc in dataset:
text = doc[&quot;chunk&quot;]
chunked_texts = chunk_text(text)
chunked_data.extend(chunked_texts)</p>

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

from sentence_transformers import SentenceTransformer
from lancedb import lancedb

<p># โหลดโมเดล Sentence Transformer
model = SentenceTransformer(&#039;all-MiniLM-L6-v2&#039;)</p>

<p># สร้างฐานข้อมูลเวกเตอร์ LanceDB
db = lancedb.lancedb(&#039;/path/to/store&#039;)
db.create_collection(&#039;docs&#039;, vector_dimension=model.get_sentence_embedding_dimension())</p>

<p># อินเด็กซ์เอกสาร
for text in chunked_data:
vector = model.encode(text).tolist()
db.insert_document(&#039;docs&#039;, vector, text)</p>

<p>from sentence_transformers import SentenceTransformer
from lancedb import lancedb</p>

<p># โหลดโมเดล Sentence Transformer
model = SentenceTransformer(&#039;all-MiniLM-L6-v2&#039;)</p>

<p># สร้างฐานข้อมูลเวกเตอร์ LanceDB
db = lancedb.lancedb(&#039;/path/to/store&#039;)
db.create_collection(&#039;docs&#039;, vector_dimension=model.get_sentence_embedding_dimension())</p>

<p># อินเด็กซ์เอกสาร
for text in chunked_data:
vector = model.encode(text).tolist()
db.insert_document(&#039;docs&#039;, vector, text)

เมื่อเอกสารถูกอินเด็กซ์แล้ว เราสามารถทำการค้นหาตามขั้นตอนแรกได้โดยการค้นหาสมาชิกที่ใกล้ที่สุดของเวกเตอร์คำถาม

from transformers import AutoTokenizer

<p>tokenizer = AutoTokenizer.from_pretrained(&quot;bert-base-uncased&quot;)</p>

<p>def chunk_text(text, chunk_size=512, overlap=64):
tokens = tokenizer.encode(text, return_tensors=&quot;pt&quot;, truncation=True)
chunks = tokens.split(chunk_size - overlap)
texts = [tokenizer.decode(chunk) for chunk in chunks]
return texts</p>

<p>chunked_data = []
for doc in dataset:
text = doc[&quot;chunk&quot;]
chunked_texts = chunk_text(text)
chunked_data.extend(chunked_texts)

การเรียงลำดับใหม่

หลังจากการค้นหาตามขั้นตอนแรก เราจะใช้โมเดลการเรียงลำดับใหม่เพื่อจัดเรียงเอกสารที่ค้นหามาได้ใหม่ตามความเกี่ยวข้องกับคำถาม ในตัวอย่างนี้ เราจะใช้ ColBERT ซึ่งเป็นโมเดลการเรียงลำดับที่เร็วและแม่นยำซึ่งออกแบบมาเฉพาะสำหรับการจัดอันดับเอกสาร

from lancedb.rerankers import ColbertReranker

reranker = ColbertReranker()

<p># การเรียงลำดับใหม่ของเอกสารตามขั้นตอนแรก
reranked_docs = reranker.rerank(query, initial_docs)

รายการ reranked_docs ตอนนี้มีเอกสารที่จัดเรียงใหม่ตามความเกี่ยวข้องกับคำถาม ตามที่โมเดลการเรียงลำดับใหม่ของ ColBERT ระบุ

การเพิ่มข้อมูลและสร้าง

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

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

<p>tokenizer = AutoTokenizer.from_pretrained(&quot;t5-base&quot;)
model = AutoModelForSeq2SeqLM.from_pretrained(&quot;t5-base&quot;)</p>

<p># การเพิ่มข้อมูลคำถามด้วยเอกสารที่จัดเรียงใหม่
augmented_query = query + &quot; &quot; + &quot; &quot;.join(reranked_docs[:3])</p>

<p># การสร้างคำตอบจากโมเดลภาษา
input_ids = tokenizer.encode(augmented_query, return_tensors=&quot;pt&quot;)
output_ids = model.generate(input_ids, max_length=500)
response = tokenizer.decode(output_ids[0], skip_special_tokens=True)</p>

print(response)