RAG 系统质量优化：Reranker + HyDE + Self-RAG 进阶技术完全指南

การสร้างระบบ RAG (Retrieval-Augmented Generation) ที่มีคุณภาพสูงไม่ใช่เรื่องง่าย โดยเฉพาะเมื่อต้องการความแม่นยำในการค้นหาข้อมูลและการสร้างคำตอบ ในบทความนี้เราจะมาดูเทคนิคขั้นสูง 3 อย่างที่จะช่วยยกระดับ RAG ของคุณ ได้แก่ Reranker HyDE (Hypothetical Document Embeddings) และ Self-RAG พร้อมตัวอย่างโค้ดที่ใช้งานได้จริงกับ HolySheep AI

ทำไมต้องอัพเกรด RAG ด้วยเทคนิคขั้นสูง

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

Reranker: การจัดลำดับผลลัพธ์ใหม่ด้วย Cross-Encoder

Reranker เป็นเทคนิคที่ใช้ Cross-Encoder model ประเมินความเกี่ยวข้องระหว่าง Query กับเอกสารแต่ละชิ้นอย่างละเอียด แทนที่จะใช้แค่ Vector Similarity ธรรมดา ทำให้ได้ผลลัพธ์ที่แม่นยำกว่าเดิมมาก โดยเราจะใช้ HolySheep AI สำหรับ Embedding และ Reranker API

import requests
import numpy as np

class AdvancedRAGWithReranker:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def create_embeddings(self, texts: list) -> list:
        """สร้าง Embeddings ด้วย HolySheep AI"""
        response = requests.post(
            f"{self.base_url}/embeddings",
            headers=self.headers,
            json={
                "model": "text-embedding-3-small",
                "input": texts
            }
        )
        return [item["embedding"] for item in response.json()["data"]]
    
    def rerank_documents(self, query: str, documents: list, top_k: int = 5):
        """ใช้ Reranker จัดลำดับเอกสารใหม่ด้วย Cross-Encoder"""
        response = requests.post(
            f"{self.base_url}/rerank",
            headers=self.headers,
            json={
                "model": "cohere-rerank-multilingual-v3.0",
                "query": query,
                "documents": documents,
                "top_n": top_k
            }
        )
        results = response.json()["results"]
        return [(doc["index"], doc["relevance_score"]) for doc in results]

ตัวอย่างการใช้งาน
rag_system = AdvancedRAGWithReranker(api_key="YOUR_HOLYSHEEP_API_KEY")

เอกสารในฐานข้อมูล
documents = [
    "นโยบายการคืนสินค้าภายใน 30 วัน สำหรับลูกค้าที่ซื้อสินค้าออนไลน์",
    "วิธีการติดตั้งเครื่องปรับอากาศแบบแขวนเพดาน",
    "ขั้นตอนการสมัครสมาชิก VIP และสิทธิประโยชน์ต่างๆ",
    "คู่มือการใช้งานแอปพลิเคชัน mobile banking",
    "โปรโมชันลดราคาฤดูหนาว 50% สำหรับสินค้าทุกประเภท"
]

query = "วิธีการคืนสินค้าและเงื่อนไขการคืนเงิน"
reranked = rag_system.rerank_documents(query, documents, top_k=3)

print("เอกสารที่เกี่ยวข้องมากที่สุดหลัง Reranking:")
for idx, score in reranked:
    print(f"  - {documents[idx]} (คะแนน: {score:.4f})")

HyDE (Hypothetical Document Embeddings): สร้างเอกสารสมมติก่อนค้นหา

HyDE เป็นเทคนิคที่สร้าง "เอกสารตอบปัญหา" ขึ้นมาก่อน แล้วค่อยนำไปค้นหาในฐานข้อมูล ทำให้การค้นหามีทิศทางที่ชัดเจนขึ้น วิธีนี้เหมาะมากกับคำถามที่ต้องการข้อมูลเชิงลึกหรือคำตอบที่ซับซ้อน

import requests

class HyDERAG:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def generate_hypothetical_document(self, query: str) -> str:
        """สร้างเอกสารสมมติจากคำถามด้วย GPT-4.1 ของ HolySheep"""
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=self.headers,
            json={
                "model": "gpt-4.1",
                "messages": [
                    {
                        "role": "system",
                        "content": "คุณเป็นผู้เชี่ยวชาญในการเขียนเอกสารตอบคำถาม ให้สร้างเอกสารที่ตอบคำถามนี้อย่างครบถ้วนและละเอียด เขียนเป็นภาษาไทย"
                    },
                    {
                        "role": "user",
                        "content": f"คำถาม: {query}\n\nให้สร้างเอกสารที่ตอบคำถามนี้อย่างละเอียด"
                    }
                ],
                "max_tokens": 500,
                "temperature": 0.3
            }
        )
        return response.json()["choices"][0]["message"]["content"]
    
    def create_embedding(self, text: str) -> list:
        """สร้าง Embedding ด้วย HolySheep AI"""
        response = requests.post(
            f"{self.base_url}/embeddings",
            headers=self.headers,
            json={
                "model": "text-embedding-3-large",
                "input": text
            }
        )
        return response.json()["data"][0]["embedding"]
    
    def search_with_hyde(self, query: str, document_chunks: list, top_k: int = 5):
        """ค้นหาด้วย HyDE: สร้างเอกสารสมมติ -> Embed -> ค้นหา"""
        # ขั้นตอนที่ 1: สร้างเอกสารสมมติ
        hypothetical_doc = self.generate_hypothetical_document(query)
        print(f"เอกสารสมมติที่สร้าง:\n{hypothetical_doc}\n")
        
        # ขั้นตอนที่ 2: สร้าง Embedding จากเอกสารสมมติ
        hypo_embedding = self.create_embedding(hypothetical_doc)
        
        # ขั้นตอนที่ 3: คำนวณความคล้ายคลึงกับเอกสารจริงในฐานข้อมูล
        chunk_embeddings = [self.create_embedding(chunk) for chunk in document_chunks]
        
        similarities = []
        for i, chunk_emb in enumerate(chunk_embeddings):
            similarity = np.dot(hypo_embedding, chunk_emb) / (
                np.linalg.norm(hypo_embedding) * np.linalg.norm(chunk_emb)
            )
            similarities.append((i, similarity, document_chunks[i]))
        
        # เรียงลำดับตามความคล้ายคลึง
        similarities.sort(key=lambda x: x[1], reverse=True)
        return similarities[:top_k]

ตัวอย่างการใช้งาน HyDE
hyde_system = HyDERAG(api_key="YOUR_HOLYSHEEP_API_KEY")

query = "วิธีการยื่นภาษีประจำปีออนไลน์ต้องเตรียมเอกสารอะไรบ้าง"
document_chunks = [
    "การยื่นภาษีออนไลน์ผ่านระบบ e-Filing ต้องเตรียมใบแนบเสียภาษี ภ.ง.ด.90/91",
    "วิธีการทำอาหารญี่ปุ่นที่บ้าน ใช้วัตถุดิบสดใหม่จากซูเปอร์มาร์เก็ต",
    "ขั้นตอนการเตรียมเอกสารภาษีเงินได้บุคคลธรรมดา ประกอบด้วย สลิปเงินเดือน ดอกเบี้ยเงินกู้ และใบเสร็จรับเงินค่ารักษาพยาบาล",
    "รายละเอียดการคำนวณภาษีแบบขั้นบันได อัตราภาษี 5-35% ขึ้นอยู่กับขั้นรายได้",
    "การใช้งานโปรแกรม Excel ขั้นสูงสำหรับการวิเคราะห์ข้อมูลทางธุรกิจ"
]

results = hyde_system.search_with_hyde(query, document_chunks, top_k=3)
print("ผลลัพธ์การค้นหาด้วย HyDE:")
for idx, score, chunk in results:
    print(f"  [{score:.4f}] {chunk}")

Self-RAG: การประเมินและปรับปรุงการดึงข้อมูลอัตโนมัติ

Self-RAG เป็นเทคนิคที่ให้ LLM ประเมินความเกี่ยวข้องของเอกสารที่ดึงมาได้ด้วยตัวเอง และตัดสินใจว่าจะใช้ข้อมูลนั้นหรือไม่ หรือต้องค้นหาเพิ่มเติม ทำให้ระบบมีความ�