---

LLM Note 5

Data Mastery Series — Episode 61: 6 Hallucination, วิธีสังเกต Python ถูกสร้างโดย AI หรือไม่, Evaluating LLM systems

Connect with me and follow our journey: Linkedin, Facebook

1) แก้ปัญหา Hallucination 6 ประเภทใน Small LLMs: แนวทางปฏิบัติแบบลงมือทำ

(SOURCE)บทความนี้นำเสนอแนวทางปฏิบัติจริงในการจัดการ “Hallucinations” หรือข้อผิดพลาดที่เกิดจากการคาดเดาหรือแต่งข้อมูลขึ้นมาเองโดยโมเดลภาษา (LLMs) โดยเฉพาะในกรณีที่ใช้โมเดลขนาดเล็ก เช่น LLaMA 3 1B ร่วมกับ embedding model ขนาดเล็กอย่าง Tiny GTE (45MB) ซึ่งเหมาะกับงานบนเครื่อง local หรืองบประมาณจำกัด

ประเภทของ Hallucinations และแนวทางแก้ไข (6 ประเภท)

Ref: Types of Hallucinations (Created by Fareed Khan)

1.1) **Factual Hallucination (**ข้อมูลผิดหรือแต่งขึ้น)

• ลักษณะ: ให้ข้อมูลผิด (เช่น ระบุผู้ค้นพบผิด)
• วิธีแก้: ใช้ RAG (Retrieval-Augmented Generation) โดยดึงข้อมูลจากฐานความรู้ภายนอกมาใช้ตอบคำถาม

ใช้ embedding similarity เพื่อหาข้อมูลที่เกี่ยวข้องที่สุดจาก knowledge base

similarity_scores = np.dot(document_embeddings, user_query_embedding)
retrieved_context = documents[np.argmax(similarity_scores)]

แบบละเอียด: การแก้ไขข้อเท็จจริงโดยใช้ RAG (Factual Correction Using RAG)

system prompt กำหนดพฤติกรรมหรือบทบาทของ AI

system_prompt = "You are an AI Chatbot!"

user prompt คือคำถามหรือ input จริงจากผู้ใช้

user_prompt = "Who discovered Penicillin in 1928?"

สร้าง response จาก AI โดยใช้ system และ user prompts

response = generate_response(system_prompt, user_prompt)

พิมพ์ response ที่ return โดย AI

print(response)

คำตอบที่ AI ตอบ (ถ้าลองหลายๆครั้ง อาจได้คำตอบที่ถูกต้องบ้าง แต่ใน Production version ตอบผิดเป็นสิ่งที่รับได้ยาก)

"Robert Withering, an English physician, is often credited with the discovery of penicillin in…"

คำตอบที่ถูกต้อง

"Penicillin ถูกค้นพบในปี 1928 โดย Alexander Fleming"

คุณอาจรู้แล้วว่า RAG (Retrieval-Augmented Generation) เป็นหนึ่งในเทคนิคที่พบบ่อยที่สุดในการแก้ปัญหานี้

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

Factual Hallucination (Created by Fareed Khan)

ให้เรากำหนด knowledge base ของเรา:

Knowledge Base ของเรา (5 Documents)

documents = [
"Robert Withering, an English physician and botanist, is known for his study of the foxglove plant and its medicinal properties, particularly its use in treating dropsy (edema).",
"The process of fermentation is a metabolic process that produces chemical changes in organic substrates through the action of enzymes. It typically occurs in yeast and bacteria, and also in oxygen-starved muscle cells, as in the case of lactic acid fermentation.",
"Sir Alexander Fleming, a Scottish physician and microbiologist, discovered the antibiotic substance penicillin from the mould Penicillium notatum in 1928. This discovery revolutionized medicine.",
"The Eiffel Tower is a wrought-iron lattice tower on the Champ de Mars in Paris, France. It was named after the engineer Gustave Eiffel, whose company designed and built the tower."
]

knowledge base ของเรามีห้า documents ที่ LLM ของเราจะใช้เพื่อตอบ query ของเรา มาสร้าง RAG pipeline อย่างง่ายนั้นและดูว่ามันปรับปรุง LLM ของเราหรือไม่

Embed user query

user_query = "Who discovered Penicillin in 1928?" # Query ทดสอบของเรา
user_query_embedding = get_sentence_embedding(user_query)

Embed Knowledge Base

document_embeddings = [get_sentence_embedding(doc) for doc in documents]

ค้นหา document ที่เกี่ยวข้องมากที่สุดโดยอิงตาม embedding similarity (ใช้ dot product)

similarity_scores = np.dot(document_embeddings, user_query_embedding)

ค้นหา index ของ document ที่มีคะแนนสูงสุด

most_relevant_doc_index = np.argmax(similarity_scores)

ดึงข้อความของ document ที่เกี่ยวข้องมากที่สุด

retrieved_context = documents[most_relevant_doc_index]

มาสร้าง system และ user prompt นั้นและดูว่า response ของ LLM จะเป็นอย่างไร

เราบอก AI อย่างชัดเจนให้ใช้ context ที่ให้ไว้

rag_system_prompt = f"""You are an AI Chatbot!
Use the following context to answer the user's question accurately.
If the context does not contain enough information to answer the question,
respond that you don't have sufficient information from the provided context.

Context:
{retrieved_context}
"""

user prompt ยังคงเหมือนเดิม

user_prompt = "Who discovered Penicillin in 1928?"

สร้าง response โดยใช้ RAG system prompt และ original user prompt

rag_response = generate_response(rag_system_prompt, user_prompt)

พิมพ์ RAG-enhanced response

print(rag_response)

คำตอบที่ AI ตอบ ซึ่งถูกต้อง

"Penicillin was actually discovered by Sir Alexander Fleming, a Scottish physician and microbiologist."

1.2) Temporal Hallucination (ใช้ข้อมูลที่ล้าสมัย)

• ลักษณะ: ตอบคำถามที่เกี่ยวกับเวลาโดยใช้ข้อมูลเก่า เช่น ตอบว่า “ประธานาธิบดีคนปัจจุบันของฝรั่งเศสคือ Macron” แม้เวลาผ่านไปแล้ว
• วิธีแก้: ใช้ Time-Aware Prompting แทนคำอย่าง “today” ด้วยวันที่จริง เช่น “05 May 2025”

def make_query_time_aware(user_prompt: str) -> str:
return user_prompt.replace("today", datetime.now().strftime("%d %B %Y"))

แบบละเอียด: การแก้ไขข้อมูลที่ล้าสมัยโดยใช้ Time-Aware Prompting (Temporal Correction Using Time-Aware Prompting)

• Temporal hallucinations เกิดขึ้นเมื่อ LLM สร้างข้อผิดพลาดที่เกี่ยวกับเวลาหรือข้อมูลที่ล้าสมัย
• เนื่องจาก LLMs มี “knowledge cutoff” ที่แน่นอน (พวกเขารู้จักโลกจนถึงวันที่ training เท่านั้น)

ดูตัวอย่างนี้:

system prompt กำหนดพฤติกรรมหรือบทบาทของ AI

system_prompt = "You are an AI Chatbot!"

user prompt คือคำถามหรือ input จริงจากผู้ใช้

user_prompt = "Who is the president of France today?"

สร้าง response จาก AI โดยใช้ system และ user prompts

response = generate_response(system_prompt, user_prompt)

พิมพ์ response ที่ return โดย AI

print(response)

คำตอบที่ AI ตอบ

"The current President of France is Emmanuel Macron."

วิธีหนึ่งในการแก้ปัญหานี้คือการใช้ RAG แต่มันไม่จำเป็นเสมอไปที่จะต้องมี knowledge base ที่เกี่ยวข้องพร้อมใช้งาน แล้วเราจะจัดการกับกรณีนั้นได้อย่างไร?

Temporal Hallucination (Created by Fareed Khan)

Qian et al. เสนอ TimeR4 ซึ่งเป็น framework ที่เขียน query ใหม่เพื่อให้มี time constraints เราสามารถใช้ time-aware prompting approach นี้ ซึ่งหมายความว่าเราทำให้ LLM ทราบถึง timeframe ของ query ที่ถูกถาม

• วันนี้ → 5 พฤษภาคม 2025
• ปีนี้ → 2025
• เดือนนี้ → พฤษภาคม
• …และอื่นๆ วิธีนี้ เราแนะนำ LLM ของเราด้วย rephrased query ที่ระบุ timeframe ที่อ้างถึงอย่างชัดเจน ทำให้ LLM สามารถตอบสนองได้อย่างแม่นยำมากขึ้นโดยอิงจาก training data

สิ่งนี้ยังสามารถปรับปรุง RAG retrieval quality ได้เนื่องจากเรากำลังรวม timeframe เข้าไปด้วย

มาใช้ time-aware prompting technique นี้กัน

from datetime import datetime

def make_query_time_aware(user_prompt: str) -> str:
"""
เขียน user prompt ใหม่เพื่อให้มี current date สำหรับ temporal context
นี่คือตัวอย่างที่ง่ายขึ้นโดยกำหนดเป้าหมาย keywords เฉพาะ

Parameters:  
- user_prompt (str): original user query  
  
Returns:  
- str: rewritten, time-aware query  
"""  
current_date_str = datetime.now().strftime("%d %B %Y") # เช่น "05 May 2025"  
  
# การแทนที่อย่างง่าย - ขยายสิ่งนี้สำหรับ temporal keywords เพิ่มเติม  
rewritten_prompt = user_prompt.replace("today", current_date_str)  
rewritten_prompt = rewritten_prompt.replace("this year", datetime.now().strftime("%Y"))  
rewritten_prompt = rewritten_prompt.replace("this month", datetime.now().strftime("%B %Y"))  

# คุณอาจเพิ่ม logic หรือ regex ที่ซับซ้อนมากขึ้นสำหรับ temporal phrases ที่แตกต่างกัน  
  
return rewritten_prompt

ให้รัน function นี้บน query ของเรา:

มาใช้สิ่งนี้กับ original temporal query ของเรา

user_prompt = "Who is the president of France today?"
time_aware_user_prompt = make_query_time_aware(user_prompt)

print(f"Original Query: {user_prompt}")
print(f"Time-Aware Query: {time_aware_user_prompt}")

คำตอบที่ AI ตอบ

"""
Original Query: Who is the president of France today?
Time-Aware Query: Who is the president of France 05 May 2025?
"""

ตอนนี้ เราใช้ time_aware_user_prompt นี้กับ original simple system prompt ของเราเพื่อสร้าง response

system prompt ไม่จำเป็นต้องเปลี่ยนแปลง เนื่องจาก temporal information ถูกฝังโดยตรงใน user query เอง

system prompt ยังคงเรียบง่าย

system_prompt = "You are an AI Chatbot!"

สร้าง response โดยใช้ simple system prompt และ time-aware user prompt

temporal_response = generate_response(system_prompt, time_aware_user_prompt)

พิมพ์ time-aware response

print(temporal_response)

คำตอบที่ AI ตอบ

"""
I'm an AI chatbot, and my training data is up to December 2023
"""

**1.3) Contextual Hallucination (**เพิ่มข้อมูลที่ต้นฉบับไม่ได้กล่าวถึง)

• ลักษณะ: สรุปหรืออ้างข้อมูลที่ไม่อยู่ในบริบท เช่น กล่าวถึง “การจัดปาร์ตี้” ที่ไม่มีในรายงาน
• วิธีแก้: ใช้ Lookback Lens ให้ LLM ตรวจสอบว่าข้อความที่สร้างขึ้นมีข้อมูลตรงกับ source จริงหรือไม่

ตรวจสอบข้อความสรุปกับ source context

Output: "Partially Supported" → regenerate

แก้ไขปัญหาตามบริบทโดยใช้ Lookback Lens (Contextual Issue Using Lookback Lens)

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

ดูตัวอย่างนี้:

source context ของเรา (แสดงถึง document หรือ retrieved chunk)

source_context = """ByteBuilders Q3 profit: ~5.02% adj, 4.9% unadj,
+502 bps margin, –0.1 ppt FX drag, vs. 4.5% est."""

system prompt (Report + System prompt)

system_prompt = f"""You are an AI Chatbot!

Article Snippet:
{source_context}
"""

user prompt คือการขอ summary

user_prompt = "Summarize the Q3 earnings."

สร้าง response โดยใช้ system prompt พร้อม context

response = generate_response(system_prompt, user_prompt)

พิมพ์ response ที่ return โดย AI

print(response)

source context ของเรา (ค่อนข้างซับซ้อน) ซึ่งอาจเป็น retrieved chunk, document หรือ web search result โดยพื้นฐานแล้วคือ financial report ของบริษัท ByteBuilders

เนื่องจากข้อมูลพร้อมใช้งานแล้วใน document เราจึงขอให้ LLM ของเราสรุป

นี่คือ response ที่เราได้รับ:

'''
ByteBuilders reported Q3 earnings (4th quarter) with a net profit of approximately 4.
'''

มันให้ค่า net profit ไม่ถูกต้อง แม้ว่าค่าที่ถูกต้องจะอยู่ใน document อย่างชัดเจน นี่คือ ground truth ของเรา:

• Quarter mix‑up: Q3 คือไตรมาสที่สาม ไม่ใช่ไตรมาสที่สี่
• Wrong profit figure: profit เพิ่มขึ้นไม่ได้ “ประมาณ 4” (เปอร์เซ็นต์หรืออื่นๆ) ใน context ของเรา ByteBuilders จริงๆ แล้วรายงาน 5.02% adjusted profit growth (เทียบกับ 4.50% ที่คาดการณ์ไว้)

Contextual Hallucination (Created by Fareed Khan)

เราสามารถใช้วิธีที่คล้ายกับ Lookback Lens เพื่อให้แน่ใจว่า factual claim ที่โมเดลทำได้รับการสนับสนุนโดย input context ที่ให้ไว้

เราสามารถนำ critical pieces of information จาก generated summary (เช่น “net profit of 4”) และนำเสนอเป็น explicit verification questions ให้กับ LLM โดยให้ source_context ดั้งเดิมอีกครั้งและขอให้ทำหน้าที่เป็น fact-checker

source context ของเรา (แสดงถึง document หรือ retrieved chunk)

source_context = """ByteBuilders Q3 profit: ~5.02% adj, 4.9% unadj,
+502 bps margin, –0.1 ppt FX drag, vs. 4.5% est."""

Fact checking system prompt

verification_system_prompt = f"""You are a fact-checking assistant.
Your task is to determine if the following STATEMENT is
fully and directly supported by the provided CONTEXT.

Answer (only one option to select):

1. Yes
2. No
3. Partially Supported

CONTEXT:
{source_context}
"""

Proper naming (Last summarized response = hallucinated summary)

hallucinated_summary = response

เรากำลังกำหนด verification system prompt ซึ่งจะถูกส่งไปพร้อมกับ hallucinated summarized information เพื่อดูว่า response ของ LLM ของเราจะเป็นอย่างไร

สร้าง response โดยใช้ system prompt พร้อม context

verify = generate_response(source_context, hallucinated_summary)

พิมพ์ response ที่ return โดย AI

print(verify)

Response ที่เราได้รับคือ:

'''
Based on the provided context, The statement is partially supported
'''

เราสามารถใช้ verification information นี้และอิงตามนั้น ไม่ว่าจะขอให้ LLM สร้าง summarized response ใหม่ หรือเปลี่ยนเส้นทาง task ไปยัง LLM ที่มีประสิทธิภาพมากขึ้นเพื่อสร้าง summary ที่แม่นยำยิ่งขึ้นสำหรับ query มาทำสิ่งนั้นและดูว่ามันมีผลต่อ response อย่างไร

ตัดสินใจโดยอิงตาม verification outcome

if "No" in verify or "Partially" in verify:

# สร้าง summarized info ใหม่  
response = generate_response(improved_system_prompt, user_prompt)  

# แสดง new response  
print(response)  

else:
pass

มาดู generated response กัน:

'''
ByteBuilders reported Q3 earnings of ~5.02% annualized growth
'''

Note: source_context นั้นต้องเอา Retrieve Document มานะ

1.4) Linguistic Hallucination (เหมือนจะถูกแต่ไม่ใช้ความจริง)

• ลักษณะ: ข้อความสวยหรูแต่ไม่มีเนื้อหาหรือผิด เช่น “พืชเปลี่ยนแสงอาทิตย์เป็นคลื่นเสียง”
• วิธีแก้: วัด Embedding Similarity ระหว่าง prompt กับแต่ละ output แล้ว regenerate ข้อความที่ได้คะแนนต่ำ

หาก similarity score < threshold → regenerate

if score < 50:
regenerated_response = generate_response(system_prompt, user_prompt)

แก้ไขปัญหาทางภาษาโดยใช้ Semantic Coherence Filtering (Linguistic Issue Using Semantic Coherence Filtering)

• Linguistic hallucinations เกิดขึ้นเมื่อ language model สร้าง sentences ที่ฟังดูถูกต้องและสมเหตุสมผลตามหลักไวยากรณ์ แต่ความหมายไม่ถูกต้อง ไม่เกี่ยวข้องหรือไม่สมเหตุสมผล
• ผลลัพธ์ดูดีบนพื้นผิว แต่ขาดเนื้อหาที่เป็นจริงหรือมีประโยชน์
• พิจารณาเมื่อมีคน 10 คนถามคำถามที่คล้ายกันกับ LLM พร้อมกัน หรือส่ง prompt เดียวกันหลายครั้ง มีความเป็นไปได้จริงที่หนึ่งคนขึ้นไปอาจพบปัญหานี้

Linguistic Hallucination (Created by Fareed Khan)

ดูตัวอย่างนี้:

system prompt กำหนดพฤติกรรมหรือบทบาทของ AI

system_prompt = "You are an AI Chatbot!"

user prompt คือคำถามหรือ input จริงจากผู้ใช้

user_prompt = "Explain how photosynthesis works in plants"

สร้าง list เพื่อเก็บ generated responses หลายรายการ

responses = []

Loop เพื่อสร้าง responses ที่แตกต่างกัน 10 รายการ

for i in range(10):

สร้าง Responses

response = generate_response(system_prompt, user_prompt)

ผนวก generated response ไปยัง list

responses.append(response)

เรากำลังใช้ query ที่ง่ายมากซึ่ง training data ของ LLMs จำนวนมากน่าจะมีรวมอยู่ด้วย

ตอนนี้เราได้สร้าง responses แล้ว มาสร้าง similarity score ระหว่าง query และ generated responses เพื่อระบุว่าปัญหาอยู่ที่ใด

รับ embedding สำหรับ user's query

user_query_embedding = get_sentence_embedding(user_query)

รับ embeddings สำหรับ responses ทั้งหมด

response_embeddings = [get_sentence_embedding(response) for response in responses]

คำนวณ similarity scores ระหว่าง query และแต่ละ response โดยใช้ dot product

similarity_scores = np.dot(response_embeddings, user_query_embedding)

พิมพ์คะแนน sim

print(similarity_scores)

คะแนนของเราคือ:

array([68.78545 , 69.63894 , 67.53516 , 67.09607 , 32.15152, 67.746735,
67.09607 , 69.6586 , 28.45125, 69.6586 ], dtype=float32)

มี 2 คำตอบที่ indices (4, 8) หรือคำตอบที่ 5 กับ 9 มี very low similarity scores. มาพิมพ์หนึ่งใน low score response และตรวจสอบว่ามีปัญหาอะไรบ้าง:

พิมพ์ Response ที่ index 4

print(f"response[4]: {responses[4]}")

คำตอบที่ AI ตอบ

"""
Photosynthesis is a process where plants turn sunlight into sound waves, which they use to create energy.
"""

Note: Similarity Score ต่ำ อาจใช้เป็น Threshold เพื่อ Re-respond

1.5) Intrinsic Hallucination (ข้อมูลไม่รองรับจากเอกสารต้นทาง)

• ลักษณะ: คำตอบขัดแย้งกับข้อมูล เช่น ข้อมูลบอกว่าแม่น้ำไนล์เริ่มที่ Great Lakes แต่ LLM บอกว่าเริ่มที่ Lake Hindia
• วิธีแก้: ใช้ Contradiction Checking ด้วย NLI Model (เช่น BART-MNLI)

ตรวจว่า label คือ 'contradiction' และ score > 0.6 → regenerate

แก้ไขปัญหาภายในโดยใช้ Contradiction Checking (Intrinsic Issue Using Contradiction Checking)

• Intrinsic hallucinations คือกรณีที่ output ของ LLM ขัดแย้งหรือตีความ input source ผิด
• พูดอีกนัยหนึ่งคือโมเดลบิดเบือนข้อเท็จจริงที่กำหนดไว้อย่างไม่ถูกต้อง

source context ของเรา (แสดงถึง document หรือ retrieved chunk)

source_context = """แม่น้ำไนล์มีต้นกำเนิดจาก Great Lakes
region ในแอฟริกา"""

user prompt ของเรา

user_prompt = "แม่น้ำไนล์มีต้นกำเนิดจากที่ใด"

สร้าง response โดยใช้ system prompt พร้อม context

response = generate_response(system_prompt, user_prompt)

พิมพ์ response ที่ return โดย AI

print(response)

คำตอบที่ AI ตอบ

"""
แม่น้ำไนล์มีต้นกำเนิดจาก Lake Hindia ในแทนซาเนีย
"""

LLM output ของเราขัดแย้งกับ input โดยตรง หากต้องการตรวจจับ contradictions ระหว่าง premise (source text) และ hypothesis (Model Output) เราสามารถใช้ pre-trained BERT-based model ที่ fine-tuned สำหรับ Natural Language Inference (NLI)

Intrinsic Hallucinaion (Created by Fareed Khan)

โมเดลจะช่วยเราจำแนกความสัมพันธ์ระหว่าง premise และ hypothesis โดยเฉพาะอย่างยิ่งการค้นหา contradictions

from transformers import pipeline

กำหนด premise (source text) และ hypothesis (model output)

premise = source_context
hypothesis = response

โหลด NLI model (fine-tuned บน MNLI)

nli_pipeline = pipeline("text-classification", model="facebook/bart-large-mnli")

ใช้ prompting format สำหรับ NLI

result = nli_pipeline(f"Premise: {premise} Hypothesis: {hypothesis}")
print(result)

มาดูคะแนนของ contradiction ( “ความขัดแย้ง” หรือ “การขัดกัน”) ระหว่าง model output และ source text ของเรา

[{'label': 'contradiction', 'score': 0.9499581456184387}]

คะแนน contradiction ของเราอยู่ที่ประมาณ 95% ซึ่งสูงมาก และเป็นไปตามที่คาดไว้ เราสามารถใช้วิธีเดียวกับที่เราใช้ใน linguistic appraoch ได้ โดยเราสามารถกำหนดค่า threshold ซึ่งจะสร้าง LLM response ใหม่ และดูว่าสามารถแก้ปัญหาได้หรือไม่

กำหนด contradiction score threshold

threshold = 0.60

Iterate over the responses and regenerate if the score is below the threshold

if score < threshold:
# สร้าง response ใหม่
regenerated_response = generate_response(source_context, user_prompt)

คำตอบที่ AI ตอบ

"""
แม่น้ำไนล์มีต้นกำเนิดจาก Great Lakes region ในแอฟริกา
"""

ด้วยวิธีนี้ เราสามารถสร้าง LLM response ที่เหมาะสมโดยมีความขัดแย้งน้อยที่สุด

1.6) Extrinsic Hallucination (ขัดแย้งกันในตัวเอง)

• ลักษณะ: แต่งข้อมูลใหม่ที่ไม่มีใน source เช่น อ้างว่าอนุมัติโครงการใหม่ที่ไม่ได้พูดถึง
• วิธีแก้: ใช้ Copy/Pointer Mechanism บังคับให้ LLM ตอบจากข้อมูลในเอกสารเท่านั้น

System prompt ที่เน้นว่าให้ใช้ข้อมูลเฉพาะจาก source document

system_prompt = "Only use exact info from the text. Do not invent."

แก้ไขปัญหาภายนอกโดยใช้ Copy/Pointer Mechanism (Extrinsic Issue Using Copy/Pointer Mechanism)

• Extrinsic hallucinations เกิดขึ้นเมื่อ language model เพิ่มข้อมูลพิเศษที่ไม่ได้สนับสนุนโดย original input

Meeting summary Report

document = """
สรุปการประชุม – 10 เมษายน 2568

• อภิปรายผลการดำเนินงานไตรมาส 1 ปี 2568 และการเปิดตัวผลิตภัณฑ์ที่จะมาถึง
• CFO นำเสนอข้อเสนอเรื่องงบประมาณไตรมาส 2 ปี 2568
  """

User prompt เพื่อทดสอบ extrinsic hallucinations

user_prompt = """ช่วยสรุปการประชุมที่จัดขึ้นเมื่อวันที่ 10 เมษายน 2568
และรวมถึงการตัดสินใจเกี่ยวกับการจัดสรรงบประมาณ
หรือการอนุมัติโครงการใหม่ๆ?"""

สร้าง Responses

response = generate_response(document, user_prompt)

พิมพ์ generated response

print(response)

คำตอบที่ AI ตอบ

"""
รุปการประชุม – 10 เมษายน 2568

บทนำ

• ผู้บริหารระดับสูง นำโดย CEO เข้าร่วมการประชุม

การทบทวนผลการดำเนินงานไตรมาส 1 ปี 2568

• ทีมงานทบทวนผลการดำเนินงานไตรมาส 1 ปี 2568
  โดยเน้นที่ด้านที่ประสบความสำเร็จและความท้าทายที่เผชิญ

การอนุมัติโครงการใหม่

• คณะผู้บริหารอนุมัติโครงการใหม่หลายโครงการ รวมถึง:

• ระบบ CRM บนคลาวด์สำหรับการมีส่วนร่วมและการสนับสนุนลูกค้า
  """

เมื่อ LLM ของเราถูกตั้งค่าให้มี max new tokens ที่สูงขึ้น (เช่น 500) โมเดล 1B ขนาดเล็กของเราจะเริ่มสร้างข้อเท็จจริงที่แต่งขึ้นจำนวนมากเพื่อเติมเต็มช่องว่างของ token ซึ่งไม่ได้อยู่ในเอกสารต้นฉบับ

วิธีการที่ได้รับการพิสูจน์แล้วในการลดการหลอนภายนอกคือการใช้ pointer/copy mechanisms

Extrinsic Hallucination (Created by Fareed Khan)

เทคนิคเหล่านี้ทำให้โมเดลดึงเนื้อหาโดยตรงจาก source text แทนที่จะสร้างข้อมูลใหม่

ตัวอย่างเช่น Pointer-Generator Network ในการสรุปช่วยให้โมเดลสามารถสร้างคำศัพท์ใหม่หรือคัดลอกจาก input ก็ได้

วิธีง่ายๆ ในการบังคับการคัดลอกใน LLM ของคุณคือการใช้ system prompt ที่แนะนำให้โมเดลคัดลอกโดยตรงจาก source text

นี่คือตัวอย่างของวิธีการที่คุณสามารถจัดโครงสร้าง prompt:

system_prompt = """โปรดสรุปเอกสารต่อไปนี้
แต่ให้แน่ใจว่าจะใช้เฉพาะข้อมูลที่มีอยู่ในข้อความเท่านั้น
อย่าเพิ่มข้อเท็จจริงหรือรายละเอียดใหม่ที่ไม่ได้อยู่ในเอกสารต้นฉบับ"""

มาสร้าง response ด้วย template ที่อัปเดตนี้ และดูว่า output ของ LLM ของเราคืออะไร:

User prompt + เอกสาร

combined_info = document + user_prompt

สร้าง Responses ด้วย copying mechanism

response_with_copy = generate_response(system_prompt, combined_info)

print(response_with_copy)

คำตอบที่ AI ตอบ

"""
สรุปการประชุมที่ให้ไว้มีดังนี้:

• มีการอภิปรายผลการดำเนินงานไตรมาส 1 ปี 2568
• มีการประกาศเปิดตัวผลิตภัณฑ์สำหรับช่วงเวลาที่จะมาถึง
• CFO นำเสนอข้อเสนอเรื่องงบประมาณไตรมาส 2 ปี 2568
  """

LLM ของเราไม่ได้ใช้สมองของตัวเองในการเขียน แต่คัดลอกข้อความจาก source เดิมเท่านั้น

นี่เป็นเทคนิคที่มีประโยชน์เพราะในหลายกรณี knowledge base ของเรามีขนาดใหญ่มากและมีข้อมูลที่เกี่ยวข้องที่ต้องการเพียงแค่เรียกใช้ ไม่ต้องเรียบเรียงใหม่

Key Takeaways

• การหลอนเป็นปัญหาที่สำคัญใน LLMs และการทำความเข้าใจประเภทต่างๆ ของการหลอนเป็นสิ่งสำคัญในการแก้ไขปัญหา
• เทคนิคต่างๆ เช่น RAG, Time-Aware Prompting และ Lookback Lens สามารถใช้เพื่อลดการหลอนได้อย่างมีประสิทธิภาพ
• การใช้ LLMs ขนาดเล็กที่มีประสิทธิภาพสามารถทำได้โดยการใช้เทคนิคการลดการหลอนเหล่านี้
• การตรวจสอบความถูกต้องของข้อมูลและใช้เทคนิคการกรองมีความสำคัญต่อการสร้าง LLM ที่น่าเชื่อถือ

Terminology

• LLM (Large Language Model): โมเดลภาษาขนาดใหญ่ที่ใช้ deep learning ในการสร้างข้อความ
• Hallucination: การที่โมเดลสร้างข้อมูลขึ้นมาเองโดยไม่มีพื้นฐานจากข้อมูลจริง
• RAG (Retrieval-Augmented Generation): เทคนิคที่รวมการดึงข้อมูลจากฐานภายนอกกับการสร้างข้อความ
• Embedding: การแปลงข้อความเป็นเวกเตอร์ตัวเลขเพื่อวัดความคล้าย
• Similarity Score: ค่าความใกล้เคียงของเวกเตอร์สองชุด (มักใช้ dot product)
• Time-Aware Prompting: การแปลงคำถามให้ระบุเวลาอย่างชัดเจน
• Lookback Lens: กระบวนการตรวจสอบว่าสิ่งที่ LLM สร้างมีในต้นฉบับหรือไม่
• NLI (Natural Language Inference): โมเดลที่ตรวจสอบความสัมพันธ์ระหว่างสองประโยค เช่น contradiction
• Copy Mechanism: เทคนิคที่ให้โมเดลคัดลอกคำหรือวลีจากต้นฉบับแทนที่จะสร้างใหม่
• Semantic Coherence: การเชื่อมโยงเนื้อหาของประโยคให้สอดคล้องทางความหมาย

---

2) วิธีสังเกตว่าโค้ด Python ถูกสร้างโดย AI หรือไม่

(SOURCE)แม้ว่าเครื่องมือ AI เช่น ChatGPT จะมีประโยชน์ในการเสริมการเรียนรู้ของนักเรียน แต่การใช้มันโดยไม่เข้าใจหรือพึ่งพาเกินไปอาจบั่นทอนการเรียนรู้ที่แท้จริงได้ บทความนี้เสนอแนวทางในการสังเกตว่าโค้ด Python นั้นอาจถูกสร้างโดย LLM (Large Language Model) เช่น ChatGPT, Claude หรือ DeepSeek หรือไม่ โดยอิงจากประสบการณ์ตรงของอาจารย์ผู้สอนวิชาวิทยาศาสตร์ข้อมูลและคณิตศาสตร์

2.1) ตัวบ่งชี้ที่พบบ่อยว่าโค้ดอาจมาจาก AI

1️⃣ คอมเมนต์มากเกินไปหรือดูแปลก

• ใช้ docstring (""") แบบผิดที่ เช่น คอมเมนต์บรรทัดเดียว
• ใช้อักขระพิเศษอย่าง “≡” ในคอมเมนต์ ซึ่งนักเรียนมักจะไม่ใช้

def find_squares_adding_to_zero(mod):
"""Find two non-zero numbers a and b such that a^2 + b^2 ≡ 0 mod n."""

2️⃣ ใช้ lambda expressions โดยไม่เหมาะสม

• ใช้ lambda แบบ recursive ในสถานการณ์ที่ไม่จำเป็น
• ตัวอย่างที่ดูซับซ้อนเกินไปสำหรับผู้เรียนเริ่มต้น:

fib = (lambda f: (lambda x: f(f, x)))(lambda self, n:
n if n < 2 else self(self, n-1) + self(self, n-2))

3️⃣ การนำเข้าไลบรารีผิดตำแหน่งหรือใช้ไลบรารีแปลกใหม่

• วาง import ไว้กลางไฟล์
• ใช้ Library อย่าง functools โดยที่ยังไม่ได้เรียน

4️⃣ ชื่อฟังก์ชัน/ตัวแปรละเอียดเกินไปหรือไม่สอดคล้องกับโจทย์

• เช่น ใช้ sieve_of_eratosthenes แทน prime_finder
• นักเรียนมักใช้ชื่อที่สั้นและไม่ descriptive มากขนาดนั้น

5️⃣ ความผิดพลาดด้านตรรกะ (Logical Errors)

• AI อาจให้คำตอบที่ฟังดูดีแต่ผิด เช่น ไม่จัดการ edge case, indexing ผิด, หรือมีข้อผิดพลาดเชิงเหตุผล

2.2) แนวทางในการรับมือ

• ถ้าสงสัยให้สอบถามอย่างเปิดใจ เช่น ใช้ whiteboard coding
• ตรวจสอบความเข้าใจเบื้องหลังโค้ด ไม่ใช่แค่ผลลัพธ์
• ส่งเสริมให้ใช้ AI เพื่อ “เรียนรู้” ไม่ใช่ “เลี่ยงการเรียนรู้”

Key Takeaways

• คอมเมนต์ที่เยอะเกินควรหรือแปลกมักเป็นสัญญาณของ AI
• Lambda expressions ที่ใช้ผิดที่ผิดทางเป็นอีก red flag
• การใช้ Library แปลกหรืออยู่ผิดตำแหน่งอาจสะท้อนการคัดลอกจาก AI
• การตั้งชื่ออย่างประณีตเกินไปโดยไม่มีเหตุผลมักไม่ใช่ลายเซ็นนักเรียน
• ข้อผิดพลาดเชิงตรรกะบ่งชี้ว่าอาจไม่มีความเข้าใจจริงในโค้ด

Terminology

• LLM (Large Language Model) — โมเดลภาษาเชิงลึก เช่น ChatGPT หรือ Claude ที่สามารถสร้างข้อความหรือโค้ดได้
• Lambda Expression — ฟังก์ชันแบบไม่มีชื่อใน Python มักใช้ใน map/filter/sorted
• Docstring — คำอธิบายในรูปแบบ """…""" ที่ใช้บรรยายฟังก์ชันหรือโมดูล
• Edge Case — กรณีสุดขอบ เช่น ค่าที่ต่ำสุด/สูงสุด ที่อาจทำให้โค้ดทำงานผิดพลาด
• functools — ไลบรารีใน Python ที่มีฟังก์ชันตกแต่งเช่น lru_cache
• Recursive Function — ฟังก์ชันที่เรียกตัวเองซ้ำ
• Syntax vs. Logic Error — ความผิดพลาดในโครงสร้างโค้ดเทียบกับความผิดพลาดในแนวคิด

---

3) การประเมินระบบ LLM (Large Language Model): Metrics, challenges, and best practices

(SOURCE)ในยุคที่ AI เติบโตอย่างก้าวกระโดด ระบบ Large Language Model (LLM) ได้กลายเป็นหัวใจสำคัญของแอปพลิเคชันอัจฉริยะในหลากหลายอุตสาหกรรม ตั้งแต่ Chatbot, การสรุปข้อความ, Q&A ไปจนถึงระบบวิเคราะห์ข้อมูลเชิงลึก อย่างไรก็ตาม การจะใช้ศักยภาพของ LLM ให้เกิดประสิทธิภาพสูงสุด จำเป็นต้องมี “ระบบการประเมิน” (Evaluation) ที่เป็นระบบ มีความต่อเนื่อง และเหมาะสมกับแต่ละ Use Case

3.1) การประเมิน LLM เทียบกับการประเมินระบบ LLM

ความแตกต่างระหว่างการประเมิน LLM vs. LLM System

• LLM Evaluation คือการทดสอบตัวโมเดลอย่างเดียว เช่น GPT-4, LLaMA, Claude บน benchmark มาตรฐาน เช่น GLUE, MMLU, หรือ TruthfulQA
• LLM System Evaluation คือการประเมินระบบที่นำ LLM ไปประยุกต์ใช้ในงานเฉพาะ เช่น ระบบ RAG, Chatbot, หรือ Text-to-SQL โดยรวมถึงการประเมิน prompt, retrieval pipeline, fine-tuning, ฯลฯ
• 💡 การประเมิน LLM System ไม่ได้ประเมินแค่ “โมเดล” แต่ประเมิน “ระบบทั้งหมด” ที่ประกอบกันขึ้นมา

ตาราง 1: ตัวอย่าง Benchmarks การประเมินโมเดล LLM (By Jane Huang)

• GLUE: ชุด Benchmarks สำหรับประเมินความเข้าใจภาษาธรรมชาติ (Natural Language Understanding)
• SuperGLUE: ชุด Benchmarks ที่ซับซ้อนกว่า GLUE สำหรับประเมินความสามารถของโมเดลในการ Reasoning
• HellaSwag: แบบทดสอบที่ออกแบบมาเพื่อประเมินความสามารถของโมเดลในการคาดการณ์เหตุการณ์ที่สมเหตุสมผล
• TruthfulQA: ประเมินว่าโมเดลมีความซื่อสัตย์และหลีกเลี่ยงการสร้างข้อมูลที่เป็นเท็จหรือไม่
• MMLU: ประเมินความรู้ของโมเดลในหลากหลายสาขาวิชา เช่น คณิตศาสตร์ ประวัติศาสตร์ วิทยาศาสตร์

3.2) Frameworks และ Platforms สำหรับการประเมิน

เป็นสิ่งจำเป็นอย่างยิ่งที่จะต้องประเมิน LLM เพื่อวัดคุณภาพและประสิทธิภาพในแอปพลิเคชันที่หลากหลาย Frameworks จำนวนมากได้รับการออกแบบมาโดยเฉพาะสำหรับการประเมิน LLM ด้านล่างนี้ เราจะเน้น Frameworks ที่ได้รับการยอมรับอย่างกว้างขวางที่สุดบางส่วน เช่น Prompt Flow ใน Microsoft Azure AI Studio, Weights & Biases ร่วมกับ LangChain, LangSmith โดย LangChain, DeepEval โดย confidence-ai, TruEra และอื่นๆ

ตาราง 2: ตัวอย่าง Frameworks สำหรับการประเมิน (By Jane Huang)

• Azure AI Foundry Automated Evaluation (Microsoft): เครื่องมือประเมินอัตโนมัติใน Azure AI Foundry ช่วยให้สามารถประเมินประสิทธิภาพของโซลูชัน AI ได้อย่างรวดเร็วและแม่นยำ
• OpenAI EvalsFramework: สำหรับการประเมินคุณภาพของ LLMs ของ OpenAI โดยเน้นที่ความปลอดภัย ความเป็นประโยชน์ และความถูกต้อง
• Weights & Biases (Weights & Biases): Platform สำหรับติดตามและเปรียบเทียบผลการทดลอง Machine Learning, ทำงานร่วมกับ Frameworks ต่างๆ ได้ดี
• LangSmith (LangChain): Platform โดย LangChain สำหรับ Debugging, Testing, Evaluating, และ Monitoring Chains และ LLMs
• Vertex AI Studio (Google): แพลตฟอร์มใน Google Cloud สำหรับการสร้าง, ทดสอบ, และปรับใช้โมเดล AI รวมถึง LLMs พร้อมเครื่องมือสำหรับการประเมิน

3.3) กลยุทธ์การประเมิน: Offline vs. Online

การ launch LLM application ต้องมีความระมัดระวัง และต้องมีการใช้ทั้ง Offline Evaluation (ช่วง Dev) และ Online Evaluation (ช่วงใช้งานจริง)

1️⃣ Offline Evaluation

เหมาะสำหรับการทดสอบก่อนใช้งานจริง โดยใช้ Ground Truth หรือ Golden Datasets (ข้อมูลที่มีคำตอบถูกต้อง) เพื่อเปรียบเทียบผลลัพธ์จาก LLM เช่น:

ตัวอย่างที่ LLM สร้างขึ้น

from langchain.evaluation.qa import QAGenerateChain

llm_model = "gpt-3.5-turbo"
example_gen_chain = QAGenerateChain.from_llm(ChatOpenAI(model=llm_model))
new_examples = example_gen_chain.apply_and_parse(
[{"doc": t} for t in data[:5]]
)

llm = ChatOpenAI(temperature = 0.0, model=llm_model)
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=index.vectorstore.as_retriever(),
verbose=True,
chain_type_kwargs = {
"document_separator": "<<<<>>>>>"
}
)

การประเมินโดยใช้ LLM

from langchain.evaluation.qa import QAEvalChain

llm = ChatOpenAI(temperature=0, model=llm_model)
eval_chain = QAEvalChain.from_llm(llm)
predictions = qa.apply(examples)
graded_outputs = eval_chain.evaluate(examples, predictions)

for i, eg in enumerate(examples):
print(f"Example {i}:")
print("Question: " + predictions[i][‘query’])
print("Real Answer: " + predictions[i][‘answer’])
print("Predicted Answer: " + predictions[i][‘result’])
print("Predicted Grade: " + graded_outputs[i][‘text’])
print()

ข้อดี:

• ทำ Automation ได้ใน Dev Pipeline
• ราคาถูกกว่าการทดสอบสด
• เหมาะกับ Regression Testing

ข้อเสีย:

• ไม่สะท้อนการใช้งานจริงของผู้ใช้
• ขึ้นกับคุณภาพของ Golden Dataset ที่มักต้องใช้ Human Annotation

AI ประเมิน AI

การให้ AI ประเมินผลของโมเดลด้วย prompting แบบ “few-shot” ช่วยลดต้นทุนการประเมินในระบบขนาดใหญ่ แต่ควรใช้ร่วมกับมนุษย์ในการ “Validate” เพื่อป้องกัน Hallucination

----------------------Prompt---------------------------------------------
คุณเป็นผู้ประเมินมืออาชีพ และงานของคุณคือประเมินความแม่นยำของการดึงข้อมูล Entity เป็นคะแนนในข้อความที่กำหนด คุณจะได้รับข้อความ Entity และค่า Entity
โปรดให้คะแนนเป็นตัวเลขในระดับ 0 ถึง 1 โดยที่ 1 คือคะแนนที่ดีที่สุด และ 0 คือคะแนนที่แย่ที่สุด ใช้ค่าตัวเลขอย่างเคร่งครัดในการให้คะแนน

นี่คือตัวอย่าง:

ข้อความ: Barnes & Noble ในตัวเมืองซีแอตเทิลอยู่ที่ไหน
Entity: ชื่อคน
ค่า: Barns, Noble
คะแนน: 0

ข้อความ: หมายเลขโทรศัพท์ของ Pro Club คือ (425) 895-6535
Entity: หมายเลขโทรศัพท์
ค่า: (425) 895-6535
คะแนน: 1

ข้อความ: ในช่วง 2 ปีที่ผ่านมา ฉันได้เดินทางไปแคนาดา จีน อินเดีย และญี่ปุ่น
Entity: ชื่อประเทศ
ค่า: แคนาดา
คะแนน: 0.25

ข้อความ: เรากำลังจ้างนักวิทยาศาสตร์ข้อมูลและวิศวกรซอฟต์แวร์
Entity: ตำแหน่งงาน
ค่า: วิศวกรซอฟต์แวร์
คะแนน: 0.5

ข้อความ = ฉันไปเดินป่ากับเพื่อน Lily และ Lucy ของฉัน
Entity: ชื่อคน
ค่า: Lily
คะแนน: 0.5

2️⃣ Online Evaluation

ประเมินจากการใช้งานจริง โดยใช้ User Feedback หรือ Metrics จาก Production Log เช่น:

• Click-through rate (CTR)
• Task Success Rate
• User Satisfaction Score (CSAT)

ข้อดี:

• สะท้อนประสบการณ์ผู้ใช้จริง
• ใช้ในการ Monitor หลัง Deploy

ข้อเสีย:

• อาจมีค่าใช้จ่ายสูง
• มีความเสี่ยงด้าน Privacy และ RAI (Responsible AI)

การประเมิน Online และ Metrics

การประเมิน Online ใช้ข้อมูลจริงเพื่อวัดประสิทธิภาพและ Satisfaction

ตาราง 3: รายการ Online Metrics และรายละเอียด (By Jane Huang)

• User Engagement & Utility Metrics:
  - Visited: จำนวนผู้ใช้ที่เข้าชมฟีเจอร์ LLM
  - Submitted: จำนวนผู้ใช้ที่ส่ง Prompts
  - Responded: LLM สร้าง Responses ที่ไม่มี Error
  - Viewed: ผู้ใช้ดู Responses จาก LLM
  - Clicks: ผู้ใช้คลิกเอกสารอ้างอิงจาก LLM Response
• User Interaction:
  - User Acceptance Rate: ความถี่ที่ผู้ใช้ยอมรับ (เช่น ข้อความหรือ Feedback เชิงบวก)
  - LLM Conversation: จำนวนการสนทนา LLM โดยเฉลี่ยต่อผู้ใช้
  - Active Days: จำนวนวันที่ใช้งานฟีเจอร์ LLM ต่อผู้ใช้
  - Interaction Timing: เวลาเฉลี่ยระหว่าง Prompts และ Responses
• Quality of Response:
  - Prompt and Response Length: ความยาวเฉลี่ยของ Prompts และ Responses
  - Edit Distance Metrics: ระยะห่างเฉลี่ยในการแก้ไขระหว่าง Prompts และ Responses (บ่งบอกถึงการปรับปรุง Prompt)
• User Feedback and Retention:
  - User Feedback: จำนวน Responses พร้อม Feedback (Thumbs Up/Down)
  - Daily/Weekly/Monthly Active User: จำนวนผู้ใช้ที่ใช้งานฟีเจอร์ LLM ในช่วงเวลาที่กำหนด
  - User Return Rate: เปอร์เซ็นต์ของผู้ใช้ที่กลับมาใช้งานฟีเจอร์
• Performance Metrics:
  - Requests per Second (Concurrency): จำนวน Requests ที่ LLM ประมวลผลต่อวินาที
  - Tokens per Second: จำนวน Tokens ที่ Rendered ต่อวินาทีระหว่าง LLM Response Streaming
  - Time to First Token Render: เวลาจนกว่าจะ Render Token แรกหลังจากส่ง Prompt
  - Error Rate: อัตรา Error สำหรับ Error ประเภทต่างๆ (เช่น 401, 429)
  - Reliability: เปอร์เซ็นต์ของ Requests ที่สำเร็จ เทียบกับทั้งหมด
  - Latency: ระยะเวลาการประมวลผลเฉลี่ยระหว่างส่ง Query และรับ Response
  - GPU/CPU Utilization: การใช้งาน GPU/CPU (จำนวน Tokens, จำนวน Responses)
• Cost Metrics:
  - LLM Calls Cost: ตัวอย่าง: ค่าใช้จ่ายจาก OpenAI API Calls
  - Infrastructure Cost: ค่าใช้จ่าย Storage, Network, Computing Resources ฯลฯ
  - Operation Cost: ค่าใช้จ่าย Maintenance, Support, Monitoring, Logging ฯลฯ

RAI (Responsible AI) Metrics

Responsible AI สำคัญมากสำหรับ LLM ต้องประกันการใช้งานอย่างมีจริยธรรม และลดความเสี่ยง ใช้คำถามที่ออกแบบไว้ล่วงหน้าในหมวดหมู่ RAI ต่างๆ

ตาราง 4: หมวดหมู่ความเป็นอันตรายที่อาจเกิดขึ้นของ RAI (By Jane Huang)

• Harmful Content (เนื้อหาที่เป็นอันตราย): เนื้อหาที่อาจก่อให้เกิดอันตรายต่อบุคคลหรือสังคม อาทิ Self-harm (การทำร้ายตัวเอง), Hate (ความเกลียดชัง), Sexual (เนื้อหาทางเพศ), Violence (ความรุนแรง), Fairness (ความไม่เป็นธรรม), Attacks (การโจมตี), Jailbreaks (การหลุดออกจากคำสั่ง)
• Regulation (ข้อบังคับ): ประเด็นที่เกี่ยวข้องกับการปฏิบัติตามกฎหมายและข้อกำหนด อาทิ Copyright (ลิขสิทธิ์), Privacy and security (ความเป็นส่วนตัวและความปลอดภัย), Third-party content regulation (กฎระเบียบเนื้อหาบุคคลที่สาม), Advice related to highly regulated domains (คำแนะนำในสาขาที่ควบคุมสูง เช่น การแพทย์ กฎหมาย), Generation of malware (การสร้างมัลแวร์), Jeopardizing the security system (การทำให้ระบบความปลอดภัยตกอยู่ในความเสี่ยง)
• Hallucination (ข้อมูลที่ไม่เป็นความจริง): การสร้างข้อมูลที่ผิดพลาดหรือไม่สมเหตุสมผล อาทิ Ungrounded content: non-factual (เนื้อหาที่ไม่เป็นความจริง), Ungrounded content: conflicts (เนื้อหาที่ขัดแย้ง), Hallucination based on common world knowledge (การสร้างข้อมูลที่ไม่จริงจากความรู้ทั่วไป)
• Other categories (หมวดหมู่อื่นๆ): ประเด็นอื่นๆ ที่ควรพิจารณา อาทิ Transparency (ความโปร่งใส), Accountability (ความรับผิดชอบ), Quality of Service (QoS) disparities (ความแตกต่างของคุณภาพการบริการ), Inclusiveness (การไม่แบ่งแยก), Reliability and safety (ความน่าเชื่อถือและความปลอดภัย)

Evaluation Metrics ตามสถานการณ์การใช้งาน

ปรับแต่งเกณฑ์ตามสถานการณ์การใช้งาน ภาษาเครื่องใช้ BLEU และ METEOR Sentiment Analysis ใช้ Precision, Recall และ F1 Score

1️⃣ Summarization

Summaries ที่ถูกต้อง Cohesive และ Relevant สำคัญ ตารางที่ 5 แสดง Metrics สำหรับสรุปข้อความ

ตาราง 5: ตัวอย่าง Summarization Metrics (By Jane Huang)

• Overlap-based metrics (เมตริกที่อิงตามความทับซ้อน):
  - BLEU: วัดความแม่นยำ โดยพิจารณาจากความทับซ้อนของ n-gram (ค่า 0–1 ยิ่งใกล้ 1 ยิ่งดี)
  - ROUGE: ชุดเมตริกและซอฟต์แวร์สำหรับประเมินการสรุปข้อความอัตโนมัติและการแปลภาษา
  - ROUGE-N: วัดความทับซ้อนของ n-grams ระหว่างข้อความที่สร้างกับข้อความอ้างอิง
  - ROUGE-L: วัด Subsequence ที่ยาวที่สุด (LCS) ระหว่างข้อความที่สร้างกับข้อความอ้างอิง
  - METEOR: เมตริกอัตโนมัติสำหรับการประเมินการแปลภาษาด้วยเครื่อง โดยพิจารณาจาก Synonyms
• Semantic similarity-based metrics (เมตริกที่อิงตามความคล้ายคลึงทางความหมาย):
  - BERTScore: ใช้ BERT Embeddings เพื่อวัดความคล้ายคลึงเชิงความหมาย
  - MoverScore: ประเมินการสร้างข้อความโดยใช้ Contextualized Embeddings และ Earth Mover Distance
• Specialized in summarization (เมตริกเฉพาะสำหรับการสรุปข้อความ):
  - SUPERT: ประเมินการสรุปข้อความจากหลายแหล่งโดยไม่ต้องมีการกำกับดูแล
  - BLANC: วัดคุณภาพของการสรุปโดยไม่ต้องเข้าถึงข้อความต้นฉบับ (reference-less metric)
  - FactCC: ประเมินความสอดคล้องของข้อเท็จจริงในการสรุปข้อความแบบ Abstractive
• Others (อื่นๆ):
  - Perplexity: วัดความสามารถในการทำนายของโมเดลภาษา (ค่าต่ำกว่าแสดงถึงความสามารถในการทำนายที่ดีกว่า)

2️⃣ Q&A

เพื่อวัดประสิทธิภาพของระบบในการตอบคำถามของผู้ใช้

ตาราง 6: ตัวอย่าง Metrics สำหรับ Q&A (By Jane Huang)

• QAEval: เมตริกที่ใช้การตอบคำถามเพื่อประเมินคุณภาพเนื้อหาของการสรุป
• QAFactEval: การประเมินความถูกต้องของข้อเท็จจริงโดยใช้การตอบคำถาม
• QuestEval: เมตริก NLG (Natural Language Generation) ที่ประเมินว่า Input สองชุดที่แตกต่างกันมีข้อมูลเดียวกันหรือไม่ (รองรับ Input แบบ Multimodal และ Multilingual)

3️⃣ NER (Named Entity Recognition)

NER คือการระบุและจำแนกประเภทของคำหรือวลีที่สำคัญในข้อความ เช่น ชื่อคน, สถานที่, องค์กร, วันที่ หรือตัวเลข

ในประโยค

"นายสมชายไปเที่ยวเชียงใหม่กับบริษัท ABC เมื่อวันที่ 15 มกราคม"

ระบุ: โปรแกรม NER จะระบุว่า "สมชาย", "เชียงใหม่", "ABC" และ "15 มกราคม" เป็น Entity ที่น่าสนใจ

จำแนก: จากนั้นโปรแกรมจะจำแนกประเภทของ Entity เหล่านั้น:

- "สมชาย" เป็น ชื่อคน (Person)

- "เชียงใหม่" เป็น สถานที่ (Location)

- "ABC" เป็น องค์กร (Organization)

- "15 มกราคม" เป็น วันที่ (Date)

ตาราง 7: ตัวอย่าง Metrics สำหรับ NER (By Jane Huang)

• Classification metrics: เมตริกการจำแนกประเภท (Precision, Recall, Accuracy, F1 score, etc.) ใช้ในระดับ Entity หรือระดับ Model
• InterpretEval: แบ่งข้อมูลเป็นกลุ่มตามคุณลักษณะของ Entity (เช่น ความยาว, ความสอดคล้อง, ความหนาแน่น) แล้วประเมิน Model ในแต่ละกลุ่มแยกกัน

4️⃣ Text-to-SQL

Generalize ในคำถามภาษาธรรมชาติ ปรับเข้ากับ Database Schema และ SQL Query

ตาราง 8: Benchmarks สำหรับ Tasks Text-to-SQL (By Jane Huang)

• WikiSQL: ชุดข้อมูล Text-to-SQL ขนาดใหญ่ชุดแรก
• Spider: ชุดข้อมูล Text-to-SQL ที่ซับซ้อนและครอบคลุมหลายโดเมน
• BIRD-SQL: ชุดข้อมูล Text-to-SQL ที่ครอบคลุมหลายโดเมน และพิจารณาผลกระทบของ Database Content ที่กว้างขวาง
• SParC: ชุดข้อมูลสำหรับการทำ Semantic Parsing แบบ Cross-domain ใน Context

ตาราง 9: Evaluation Metrics สำหรับ Tasks Text-to-SQL (By Jane Huang)

• Exact-set-match accuracy (EM): ประเมินความถูกต้องของแต่ละ Clause ใน SQL Query ที่สร้างขึ้น เทียบกับ Ground Truth อย่างไรก็ตาม มีข้อจำกัด เนื่องจากมีวิธีการเขียน SQL Query ที่ให้ผลลัพธ์เดียวกันได้หลายแบบ
• Execution Accuracy (EX): ประเมินความถูกต้องของผลลัพธ์ที่ได้จากการ Execution SQL Query
• VES (Valid Efficiency Score): เมตริกที่วัดประสิทธิภาพควบคู่ไปกับความถูกต้องของการ Execution SQL Query

5️⃣ Retrieval System

RAG รวม Retrieval และ Generation การประเมินช่วยปรับปรุง

ตาราง 10: Frameworks การประเมินสำหรับ Retrieval System (By Jane Huang)

• RAGAs: Framework สำหรับประเมิน Retrieval Augmented Generation (RAG) Pipeline
• ARES: Framework อัตโนมัติสำหรับการประเมินระบบ Retrieval-Augmented Generation
• RAG Triad of metrics: ชุดเมตริก RAG Triad ที่ประกอบด้วย Answer Relevance (คำตอบมีประโยชน์หรือไม่), Context Relevance (การดึงข้อมูลดีแค่ไหน), และ Groundedness (คำตอบอ้างอิงตาม Context หรือไม่)

ตาราง 11: ตัวอย่าง Evaluation Metrics สำหรับ Retrieval System (By Jane Huang)

• Faithfulness: วัดความสอดคล้องของข้อเท็จจริงในคำตอบที่สร้างขึ้น เทียบกับ Context ที่ให้มา
• Response Relevancy: วัดความเกี่ยวข้องของ Response กับ User Input
• Context precision: ประเมินว่า Item ที่เกี่ยวข้องกับ Ground Truth ทั้งหมดอยู่ใน Context ที่ถูก Rank สูงหรือไม่
• Context relevancy: วัดความเกี่ยวข้องของ Context ที่ดึงมา โดยพิจารณาทั้งคำถามและ Context
• Context Recall: วัดว่า Context ที่ดึงมาสอดคล้องกับคำตอบที่ Annotated มากแค่ไหน (ถือเป็น Ground Truth)
• Answer Correctness: วัดความถูกต้องของคำตอบที่สร้างขึ้น เมื่อเทียบกับ Ground Truth

Key Takeaways:

• LLM Evaluation ≠ System Evaluation — ต้องดูที่ระบบโดยรวม ไม่ใช่แค่โมเดล
• Offline + Online Evaluation ควรใช้ร่วมกันเพื่อครอบคลุมการใช้งานจริง
• Golden Dataset สำคัญมาก แต่อาจใช้ AI ช่วยสร้างและตรวจสอบได้
• AI สามารถประเมินกันเองได้ แต่ต้องมีการออกแบบ Prompt และการตรวจสอบที่ดี
• RAI ต้องไม่ถูกมองข้าม ทั้งด้าน bias, safety, copyright และ fairness

Terminology:

• LLM (Large Language Model): โมเดลประมวลผลภาษาขนาดใหญ่ เช่น GPT, LLaMA
• RAG (Retrieval-Augmented Generation): การใช้ระบบค้นหาข้อมูลมาเสริมการตอบของโมเดล
• Prompt Template: โครงร่างคำสั่งที่ใช้ถาม LLM เพื่อควบคุมรูปแบบคำตอบ
• Golden Dataset: ชุดข้อมูลที่มีคำตอบถูกต้องไว้ใช้ในการประเมินผล
• Offline Evaluation: การประเมินผลแบบไม่ใช้งานจริง ใช้ชุดข้อมูลจำลอง
• Online Evaluation: การประเมินผลขณะผู้ใช้งานจริงผ่านระบบ Production
• ROUGE / BLEU / METEOR: Metrics วัดคุณภาพการสรุป/แปลข้อความ
• RAI (Responsible AI): การพัฒนา AI อย่างมีจริยธรรมและไม่ก่อให้เกิดอันตราย
• LangSmith / Prompt Flow: เครื่องมือสำหรับติดตาม ประเมิน และจัดการระบบ LLM
• InterpretEval: Metric ที่ช่วยอธิบายเหตุผลเบื้องหลังการทำนายของ NER Model

---

Data Science Explore the world of data science with Donato_Story

Dashboard Discover the power of data visualization with Donato_Story

Donato_Journey Join me on my journey (Thai version)

Course_Review Discover the training courses with Donato_Story (Thai version)

Let’s Connect!

Your thoughts and feedback are invaluable. Feel free to share them in the comments or connect with me on

• Medium: medium.com/donato-story
• Facebook: web.facebook.com/DonatoStory
• Linkedin: linkedin.com/in/nattapong-thanngam