LlamaIndex Evaluation Metrics: คู่มือวัดคุณภาพการค้นหาข้อมูลสำหรับ RAG Pipeline

บทนำ: ทำไมการประเมิน Retrieval ถึงสำคัญ

การสร้าง RAG (Retrieval-Augmented Generation) Pipeline ที่ดีไม่ได้จบแค่การตั้งค่า vector store และ embedding model เท่านั้น สิ่งสำคัญที่สุดคือการวัดว่า "ระบบค้นหาข้อมูลของเราดีจริงหรือไม่" ซึ่งในบทความนี้เราจะมาเจาะลึก metrics ที่ใช้ในการประเมิน retrieval quality ผ่าน LlamaIndex พร้อมโค้ดตัวอย่างที่ใช้งานได้จริง

กรณีศึกษา: ทีม LegalTech จากภาคเหนือของไทย

บริบทธุรกิจ

ทีม LegalTech แห่งหนึ่งในภาคเหนือของไทยพัฒนาแชทบอทให้คำปรึกษากฎหมายเบื้องต้น โดยใช้เอกสารสัญญาและคำพิพากษาศาลกว่า 50,000 ฉบับเป็น knowledge base ระบบต้องสามารถค้นหาข้อมูลที่เกี่ยวข้องได้อย่างแม่นยำ เพราะความผิดพลาดในการอ้างอิงกฎหมายอาจนำไปสู่ปัญหาทางกฎหมายได้

จุดเจ็บปวดกับผู้ให้บริการเดิม

ทีมเดิมใช้ OpenAI API สำหรับ embeddings และ generation ซึ่งมีค่าใช้จ่ายสูงมาก (บิลกว่า $4,200 ต่อเดือน) และมีปัญหาด้านความล่าช้าในการตอบสนอง (average latency 420ms) ทำให้ผู้ใช้งานบางครั้งรู้สึกว่าระบบตอบสนองช้า นอกจากนี้ยังมีปัญหาเรื่อง data privacy เนื่องจากต้องส่งข้อมูลกฎหมายที่มีความละเอียดอ่อนไปยังเซิร์ฟเวอร์ต่างประเทศ

การย้ายมาใช้ HolySheep AI

ทีมตัดสินใจย้ายมาใช้ HolySheep AI เพราะมี latency ต่ำกว่า 50ms และราคาประหยัดกว่า 85% กระบวนการย้ายประกอบด้วย 3 ขั้นตอนหลัก:

• การเปลี่ยน base_url: อัปเดตจาก api.openai.com เป็น https://api.holysheep.ai/v1
• การหมุนคีย์ API: สร้างคีย์ใหม่จาก HolySheep dashboard และอัปเดต environment variables
• Canary Deploy: ทดสอบกับ traffic 10% ก่อนขยายไปยัง 100%

ผลลัพธ์ 30 วันหลังการย้าย

ผลลัพธ์ที่ได้รับน่าประทับใจมาก: latency ลดลงจาก 420ms เหลือเพียง 180ms (ลดลง 57%) และค่าใช้จ่ายรายเดือนลดลงจาก $4,200 เหลือเพียง $680 (ประหยัด 84%) คุณภาพการตอบสนองยังคงรักษาระดับเดิมหรือดีขึ้น เนื่องจากระบบ retrieval ทำงานได้รวดเร็วและแม่นยำขึ้น

Metrics หลักในการประเมิน Retrieval Quality

1. NDCG (Normalized Discounted Cumulative Gain)

NDCG เป็น metric ที่ใช้วัดความสัมพันธ์ระหว่างเอกสารที่ระบบค้นหาได้กับความเกี่ยวข้องที่คาดหวัง โดยคำนึงถึงตำแหน่งของผลลัพธ์ด้วย ค่า NDCG ที่ดีควรอยู่ในช่วง 0.8-1.0

2. MRR (Mean Reciprocal Rank)

MRR วัดว่าเอกสารที่ถูกต้องอยู่ในอันดับที่เท่าไหร่โดยเฉลี่ย ยิ่งค่า MRR สูง (ใกล้ 1) แปลว่าระบบสามารถนำเอกสารที่ถูกต้องมาแสดงในอันดับต้นๆ ได้

3. Recall@K และ Precision@K

Recall@K วัดว่าใน K ผลลัพธ์แรก มีเอกสารที่เกี่ยวข้องถูกค้นหาเจอกี่เปอร์เซ็นต์ ส่วน Precision@K วัดว่าใน K ผลลัพธ์แรก มีกี่เปอร์เซ็นต์ที่เกี่ยวข้องจริง

4. Hit Rate

Hit Rate บอกว่าในการค้นหาทั้งหมด มีกี่เปอร์เซ็นต์ที่สามารถค้นหาเอกสารที่ถูกต้องอย่างน้อย 1 ฉบับได้

การตั้งค่า Evaluation Pipeline ด้วย LlamaIndex

ด้านล่างคือโค้ดตัวอย่างสำหรับการตั้งค่า evaluation pipeline ที่ใช้งานได้จริงกับ LlamaIndex โดยใช้ HolySheep AI เป็น LLM backend

import os
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.evaluation import RetrieverEvaluator
from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.llms.holysheep import HolySheep

ตั้งค่า HolySheep LLM
os.environ["HOLYSHEEP_API_KEY"] = "YOUR_HOLYSHEEP_API_KEY"

llm = HolySheep(
    model="gpt-4.1",
    api_key=os.environ["HOLYSHEEP_API_KEY"],
    base_url="https://api.holysheep.ai/v1"
)

โหลดเอกสาร
documents = SimpleDirectoryReader("./legal_docs").load_data()

สร้าง index
index = VectorStoreIndex.from_documents(documents)

ตั้งค่า retriever
retriever = VectorIndexRetriever(
    index=index,
    similarity_top_k=10
)

สร้าง evaluator
evaluator = RetrieverEvaluator.from_metric_names(
    ["mrr", "ndcg_at_k", "hit_rate"],
    retriever=retriever
)

รัน evaluation
eval_results = await evaluator.aevaluate(
    query_bundle=query_bundle
)

แสดงผลลัพธ์
for result in eval_results:
    print(f"MRR: {result.mrr}")
    print(f"NDCG@K: {result.ndcg_at_k}")
    print(f"Hit Rate: {result.hit_rate}")

การคำนวณ Metrics แบบ Custom

ในกรณีที่ต้องการควบคุม logic การคำนวณเอง สามารถใช้โค้ดด้านล่างนี้ได้

import numpy as np
from typing import List, Dict

def calculate_ndcg(relevance_scores: List[float], k: int = 10) -> float:
    """
    คำนวณ NDCG@k
    relevance_scores: คะแนนความเกี่ยวข้องของเอกสาร (1-5 หรือ binary 0/1)
    """
    # คำนวณ DCG
    dcg = 0.0
    for i, score in enumerate(relevance_scores[:k]):
        dcg += score / np.log2(i + 2)  # i+2 เพราะ log2(1) = 0
    
    # คำนวณ IDCG (ideal case)
    ideal_scores = sorted(relevance_scores, reverse=True)
    idcg = 0.0
    for i, score in enumerate(ideal_scores[:k]):
        idcg += score / np.log2(i + 2)
    
    # NDCG = DCG / IDCG
    return dcg / idcg if idcg > 0 else 0.0

def calculate_mrr(relevant_docs_ranks: List[int]) -> float:
    """
    คำนวณ Mean Reciprocal Rank
    relevant_docs_ranks: ลิสต์ของอันดับของเอกสารที่เกี่ยวข้อง (1-based)
    """
    if not relevant_docs_ranks:
        return 0.0
    
    reciprocal_ranks = [1.0 / rank for rank in relevant_docs_ranks]
    return np.mean(reciprocal_ranks)

def calculate_recall_at_k(
    retrieved_docs: List[str],
    relevant_docs: set,
    k: int
) -> float:
    """
    คำนวณ Recall@K
    """
    retrieved_k = set(retrieved_docs[:k])
    num_relevant_retrieved = len(retrieved_k & relevant_docs)
    return num_relevant_retrieved / len(relevant_docs) if relevant_docs else 0.0

ตัวอย่างการใช้งาน
relevance_scores = [5, 3, 0, 4, 0, 2, 1, 0, 0, 0]
ndcg = calculate_ndcg(relevance_scores, k=5)
print(f"NDCG@5: {ndcg:.4f}")

ranks = [1, 3, 2, 5]
mrr = calculate_mrr(ranks)
print(f"MRR: {mrr:.4f}")

retrieved = ["doc_1", "doc_2", "doc_3", "doc_4", "doc_5"]
relevant = {"doc_1", "doc_3", "doc_6"}
recall = calculate_recall_at_k(retrieved, relevant, k=3)
print(f"Recall@3: {recall:.4f}")

การใช้ RetrievalEvaluator กับ Golden Dataset

การประเมินที่ดีต้องมี golden dataset ที่มีคำถามและคำตอบที่ถูกต้องระบุไว้

from llama_index.core.evaluation import 
from llama_index.core.evaluation.retrieval.base import 
from typing import List, Tuple

สร้าง golden dataset
golden_dataset = [
    {
        "query": "สัญญาเช่าที่ดินมีระยะเวลาสูงสุดเท่าไหร่?",
        "relevant_docs": ["doc_1", "doc_5", "doc_12"]
    },
    {
        "query": "อายุความในการฟ้องคดีที่ดินเท่าไหร่?",
        "relevant_docs": ["doc_3", "doc_8"]
    },
    {
        "query": "ข้อยกเว้นในการครอบครองปรปักษ์มีอะไรบ้าง?",
        "relevant_docs": ["doc_7", "doc_15", "doc_22", "doc_30"]
    }
]

รัน batch evaluation
results = []
for item in golden_dataset:
    query = item["query"]
    relevant_docs = set(item["relevant_docs"])
    
    # ค้นหาด้วย retriever
    retrieved_nodes = retriever.retrieve(query)
    retrieved_docs = [node.node_id for node in retrieved_nodes]
    
    # คำนวณ metrics
    recall = calculate_recall_at_k(retrieved_docs, relevant_docs, k=5)
    hit_rate = 1.0 if len(set(retrieved_docs[:5]) & relevant_docs) > 0 else 0.0
    
    results.append({
        "query": query,
        "recall@5": recall,
        "hit_rate": hit_rate
    })

สรุปผล
avg_recall = np.mean([r["recall@5"] for r in results])
avg_hit_rate = np.mean([r["hit_rate"] for r in results])
print(f"Average Recall@5: {avg_recall:.4f}")
print(f"Average Hit Rate: {avg_hit_rate:.4f}")

การเปรียบเทียบ Embedding Models

การเลือก embedding model ที่เหมาะสมมีผลต่อคุณภาพ retrieval อย่างมาก ด้านล่างคือโค้ดสำหรับเปรียบเทียบ models ต่างๆ

from llama_index.core.evaluation import 
import time

embedding_models = [
    "text-embedding-3-small",  # OpenAI compatible
    "text-embedding-3-large",
    "bge-base-zh-v1.5",       # multilingual
    "m3e-base"
]

results = {}

for model in embedding_models:
    # สร้าง settings ใหม่สำหรับแต่ละ model
    from llama_index.core import Settings
    
    Settings.embed_model = None  # reset
    
    # วัดเวลา
    start_time = time.time()
    
    # สร้าง index และ evaluate
    index = VectorStoreIndex.from_documents(
        documents,
        embed_model=model
    )
    
    retriever = VectorIndexRetriever(
        index=index,
        similarity_top_k=10
    )
    
    eval_results = await evaluator.aevaluate(retriever=retriever)
    
    elapsed = time.time() - start_time
    
    results[model] = {
        "ndcg": np.mean([r.ndcg_at_k for r in eval_results]),
        "mrr": np.mean([r.mrr for r in eval_results]),
        "latency_ms": elapsed * 1000
    }

แสดงผลเปรียบเทียบ
print("Embedding Model Comparison:")
print("-" * 60)
for model, metrics in sorted(results.items(), 
                              key=lambda x: x[1]["ndcg"], 
                              reverse=True):
    print(f"{model}: NDCG={metrics['ndcg']:.4f}, "
          f"MRR={metrics['mrr']:.4f}, "
          f"Latency={metrics['latency_ms']:.0f}ms")

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

กรณีที่ 1: NDCG ได้ค่าต่ำผิดปกติ (0.0-0.2)

สาเหตุ: ปัญหานี้มักเกิดจากการตั้งค่า similarity_top_k ต่ำเกินไป หรือ chunk size ไม่เหมาะสมทำให้เอกสารที่เกี่ยวข้องถูกแบ่งออกจากกัน

# แก้ไข: เพิ่ม similarity_top_k และปรับ chunk size
retriever = VectorIndexRetriever(
    index=index,
    similarity_top_k=20,  # เพิ่มจาก 10 เป็น 20
    vector_store_query_mode="default"
)

ปรับ chunk size ใน ServiceContext
from llama_index.core import ServiceContext, VectorStoreIndex

ServiceContext.from_defaults(
    chunk_size=512,  # ลดจาก 1024 เพื่อให้ context มีความแม่นยำมากขึ้น
    chunk_overlap=50
)

กรณีที่ 2: MRR สูงแต่ Recall ต่ำ

สาเหตุ: ระบบสามารถหาเอกสารที่เกี่ยวข้องที่สุดได้ดี แต่อาจพลาดเอกสารที่เกี่ยวข้องอื่นๆ ซึ่งอาจเกิดจากการใช้ hybrid search ที่ไม่สมดุล

# แก้ไข: ใช้ hybrid search ที่สมดุล
from llama_index.core.retrievers import BM25Retriever

รวม vector search กับ keyword search
hybrid_retriever = QueryFusionRetriever(
    retrievers=[
        VectorIndexRetriever(index=index, similarity_top_k=10),
        BM25Retriever.from_defaults(docstore=index.docstore, k=10)
    ],
    mode=QueryFusionMode.RECIPROCAL_RANK,  # ใช้ reciprocal rank สำหรับ re-ranking
    similarity_top_k=5
)

กรณีที่ 3: Hit Rate ดีแต่ Precision ต่ำ

สาเหตุ: ระบบสามารถหาเอกสารที่เกี่ยวข้องได้ แต่มีเอกสารที่ไม่เกี่ยวข้องปนมามากเกินไป ซึ่งอาจทำให้ LLM ตอบสนองไม่ตรงประเด็น

# แก้ไข: เพิ่ม reranker และใช้ score threshold
from llama_index.core.postprocessor import SentenceTransformerRerank

เพิ่ม reranker หลังจาก retrieval
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-12-v2",
    top_n=5  # รักษาแค่ top 5 หลัง rerank
)

ใช้ reranker ใน query engine
query_engine = index.as_query_engine(
    similarity_top_k=20,  # ดึงมาก่อน 20 อัน
    node_postprocessors=[reranker]  # แล้ว rerank เหลือ 5
)

กรณีที่ 4: Evaluation ใช้เวลานานเกินไป

สาเหตุ: Golden dataset มีขนาดใหญ่เกินไป หรือ LLM API มี rate limiting

# แก้ไข: ใช้ async และ batch processing
import asyncio
from concurrent.futures import ThreadPoolExecutor

async def evaluate_batch(queries, max_concurrent=5):
    semaphore = asyncio.Semaphore(max_concurrent)
    
    async def limited_evaluate(query):
        async with semaphore:
            return await evaluator.aevaluate(query)
    
    tasks = [limited_evaluate(q) for q in queries]
    return await asyncio.gather(*tasks)

หรือใช้ cache สำหรับ embeddings
from llama_index.core import load_graph_from_storage

โหลด index ที่มีอยู่แล้วแทนการสร้างใหม่ทุกครั้ง
index = load_graph_from_storage(
    persist_dir="./storage",
    service_context=service_context
)

สรุป: Best Practices สำหรับ Retrieval Evaluation

การวัดคุณภาพ retrieval เป็นกระบวนการที่ต้องทำอย่างต่อเนื่อง ควรจัดทำ golden dataset ที่มีคุณภาพและครอบคลุม use cases หลักของระบบ ใช้หลาย metrics ประกอบกัน (ไม่ดูแค่ metric เดียว) และทำการทดสอบซ้ำทุกครั้งที่มีการเปลี่ยนแปลง configuration

สำหรับทีมที่ต้องการ optimize ค่าใช้จ่ายและ latency โดยไม่ต้องกังวลเรื่อง API reliability การใช้ HolySheep AI เป็น backend สามารถช่วยลดค่าใช้จ่ายได้ถึง 85% พร้อม latency ต่ำกว่า 50ms ทำให้การประเมินและการใช้งานจริงทำงานได้รวดเร็วขึ้นอย่างเห็นได้ชัด

ตารางเปรียบเทียบราคา Models ยอดนิยม

Model	ราคา ($/MTok)	เหมาะสำหรับ
DeepSeek V3.2	$0.42	Cost-efficient tasks, embeddings
Gemini 2.5 Flash	$2.50	Fast inference, real-time apps
GPT-4.1	$8.00	High-quality generation
Claude Sonnet 4.5	$15.00	Complex reasoning tasks

อัตราแลกเปลี่ยน ¥1=$1 รองรับการชำระเงินผ่าน WeChat และ Alipay พร้อมเครดิตฟรีเมื่อลงทะเบียน

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน