บล็อก

วิธีใช้ LLM-as-a-Judge

Markdown

ใช้โมเดลหนึ่งตัวให้คะแนนอีกโมเดลตามเกณฑ์ เรียนรู้การประเมินแบบ pointwise เทียบกับ pairwise อคติที่พบบ่อย และวิธีควบคุมอคติเหล่านั้น

ใช้โมเดลหนึ่งตัวให้คะแนนอีกโมเดลตามเกณฑ์ เรียนรู้การประเมินแบบ pointwise เทียบกับ pairwise อคติที่พบบ่อย และวิธีควบคุมอคติเหล่านั้น

LLM-as-a-judge คืออะไร

LLM-as-a-judge คือการใช้โมเดลภาษาเพื่อประเมินผลลัพธ์ของอีกโมเดลหนึ่งตามเกณฑ์ที่คุณกำหนด แทนที่จะเปรียบเทียบสตริง ผู้ประเมินจะอ่านผลลัพธ์และส่งคืนคะแนนหรือคำตัดสิน

Zheng และคณะได้วางรูปแบบแนวทางนี้ไว้อย่างเป็นทางการในปี 2023 โดยพบว่าโมเดลที่มีความสามารถสูงเห็นพ้องกับความชอบของมนุษย์มากกว่า 80% ของเวลา ซึ่งใกล้เคียงกับอัตราที่มนุษย์สองคนเห็นพ้องกัน นี่คือสิ่งที่แนวทางนี้มอบให้: การตัดสินแบบมนุษย์ในระดับและต้นทุนแบบเครื่องจักร

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

ควรใช้เมื่อใด และไม่ควรใช้เมื่อใด

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

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

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

Pointwise เทียบกับ pairwise

มีสองวิธีในการขอให้ผู้ประเมินให้คะแนน และแต่ละวิธีก็เหมาะกับงานต่างกัน

โหมดคำถามเหมาะที่สุดสำหรับจุดอ่อน
Pointwise“ให้คะแนนผลลัพธ์นี้ตั้งแต่ 1 ถึง 5 ตามเกณฑ์”คะแนนสัมบูรณ์สำหรับแดชบอร์ดหรือเกณฑ์ตรวจ CIการปรับเทียบอาจเปลี่ยนไป คะแนนเปรียบเทียบข้ามการรันได้ยาก
Pairwise“A หรือ B ดีกว่ากัน”เปรียบเทียบพรอมป์ต์สองชุดหรือโมเดลสองตัวให้ผู้ชนะ ไม่ใช่คะแนนสัมบูรณ์ และไวต่อการเรียงลำดับ

โดยทั่วไป pairwise สอดคล้องกับการตัดสินของมนุษย์มากกว่า เพราะการเปรียบเทียบเชิงสัมพัทธ์ทำได้ง่ายกว่าการปรับเทียบคะแนนสัมบูรณ์ ใช้วิธีนี้เมื่อทดสอบการเปลี่ยนแปลงแบบ A/B และใช้ pointwise เมื่อต้องการตัวเลขที่เป็นอิสระ

เขียนพรอมป์ต์สำหรับผู้ประเมิน

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

You are evaluating an answer to a user question. Judge ONLY against the rubric.
Rubric:
- Correctness: does the answer match the reference facts?
- Completeness: does it cover what the question asked?
- Groundedness: are claims supported, with no invented details?
Question: {question}
Reference: {reference}
Answer: {answer}
First, reason step by step about each rubric criterion in 1-2 sentences.
Then output a JSON verdict: {"correctness": 0-1, "completeness": 0-1,
"groundedness": 0-1, "pass": true/false}. Do not reward length or style.

มีสองจุดที่สำคัญ การขอให้ให้เหตุผลทีละขั้นก่อนตัดสิน (พรอมป์ต์แบบ chain-of-thought) ช่วยเพิ่มความสอดคล้องกับมนุษย์ และประโยคชัดเจนที่ว่า “do not reward length or style” ก็ช่วยต้านอคติที่จะกล่าวถึงต่อไปโดยตรง

อคติสี่แบบที่คุณต้องจัดการ

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

อคติสิ่งที่เกิดขึ้นวิธีลดผลกระทบ
อคติด้านตำแหน่งใน pairwise คำตอบที่อยู่ช่อง A ชนะบ่อยกว่าที่ควรจะเป็นเมื่อเทียบกับการสุ่มรันทั้งสองลำดับ (A/B และ B/A) และเชื่อเฉพาะคำตัดสินที่ตรงกันทั้งสองครั้ง
อคติด้านความยาวคำตอบที่ยาวกว่าได้คะแนนสูงกว่า แม้คุณภาพจะเท่ากันหักคะแนนเรื่องความยาวในเกณฑ์ หรือใช้อัตราชนะที่ควบคุมความยาว
ความชอบตนเองผู้ประเมินชอบผลลัพธ์จากตระกูลโมเดลของตัวเองใช้ผู้ประเมินจากตระกูลที่ต่างจากโมเดลที่กำลังทดสอบ
อคติด้านรูปแบบผู้ประเมินชอบรูปแบบที่ตนเองชอบ (เช่น ร้อยแก้วมากกว่า JSON)ระบุรูปแบบที่ต้องการในเกณฑ์ และให้คะแนนเนื้อหา ไม่ใช่รูปลักษณ์

อคติด้านตำแหน่งสำคัญที่สุด เพราะตรวจจับในโค้ดได้ง่าย และมันบิดเบือนการเปรียบเทียบแบบ pairwise ทุกครั้งที่คุณรันโดยไม่ให้สังเกตเห็น

ควบคุมอคติด้านตำแหน่งในโค้ด

วิธีแก้อคติด้านตำแหน่งตรงไปตรงมา: ประเมินแต่ละคู่สองครั้ง โดยสลับว่าผลลัพธ์ใดอยู่ก่อน และประกาศผู้ชนะก็ต่อเมื่อคำตัดสินตรงกันทั้งสองลำดับ หากผลเปลี่ยนเพียงเพราะลำดับ ผู้ประเมินกำลังเดา

# debias.py
def pairwise_debiased(x: str, y: str, judge) -> str:
    """Run the judge in both orderings. Trust the result only if it agrees."""
    first = judge(x, y)    # x in slot A
    second = judge(y, x)   # y in slot A
    x_wins = first == "A" and second == "B"
    y_wins = first == "B" and second == "A"
    if x_wins:
        return "x"
    if y_wins:
        return "y"
    return "tie/uncertain (verdict flipped on order)"
# A deliberately position-biased judge stub: it always picks slot A.
# Real judges show a smaller version of this; we exaggerate to prove the control works.
def biased_judge(a: str, b: str) -> str:
    return "A"
# A fair judge that decides on a real signal (here, conciseness) regardless of slot.
def fair_judge(a: str, b: str) -> str:
    return "A" if len(a) <= len(b) else "B"
print("biased:", pairwise_debiased("short answer", "a much longer answer", biased_judge))
print("fair:  ", pairwise_debiased("short answer", "a much longer answer", fair_judge))

วางโค้ดนี้ใน debias.py แล้วรัน python debias.py คุณจะได้ผลลัพธ์ตรงตามนี้:

biased: tie/uncertain (verdict flipped on order)
fair:   x

การลดอคติทำงานตามที่ตั้งใจ มันตรวจพบผู้ประเมินที่มีอคติและปฏิเสธที่จะเลือกผู้ชนะ ขณะเดียวกันก็ยอมรับคำตัดสินที่คงที่ของผู้ประเมินที่เป็นธรรม หากต้องการใช้ผู้ประเมินจริง ให้แทนที่ judge ด้วยฟังก์ชันที่เรียก LLM ด้วยพรอมป์ต์ตามเกณฑ์ข้างต้น แล้วส่งคืน “A” หรือ “B”

ตรวจสอบผู้ประเมินของคุณ

ก่อนเชื่อถือผู้ประเมินในระบบใช้งานจริง ให้ตรวจวัดประสิทธิภาพก่อน ผู้ประเมินที่ยังไม่ผ่านการตรวจสอบคือเมตริกที่คุณไม่สามารถอธิบายปกป้องได้

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

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

รูปแบบไฮบริด

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

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

แต่ละชั้นครอบคลุมจุดบอดของชั้นก่อนหน้า ผู้ประเมินเป็นชั้นกลางที่ทรงพลัง ไม่ใช่ระบบทั้งหมด

ข้อผิดพลาดที่พบบ่อย

ผู้ประเมินที่ไม่น่าเชื่อถือส่วนใหญ่มักมีสาเหตุร่วมกันไม่กี่ข้อ

ข้อที่พบบ่อย ได้แก่:

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

แก้ปัญหาเหล่านี้ด้วยการแยกผู้ประเมินออกจากโมเดลที่ทดสอบ เขียนเกณฑ์ให้ชัดเจน สลับลำดับทุกครั้ง และตรวจสอบกับป้ายกำกับจากมนุษย์

แหล่งข้อมูล

Zheng และคณะ, Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (NeurIPS 2023) กล่าวถึงแนวทาง LLM-as-judge การเห็นพ้องกับความชอบของมนุษย์มากกว่า 80% และอคติด้านตำแหน่ง ความยาว และการยกระดับตนเอง

คำถามที่พบบ่อย

LLM-as-a-judge คืออะไร

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

ใช้โมเดลเดียวกันสร้างและประเมินได้ไหม

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

จะหยุดอคติด้านตำแหน่งได้อย่างไร

รันการเปรียบเทียบ pairwise แต่ละครั้งในทั้งสองลำดับ และยอมรับเฉพาะคำตัดสินที่ตรงกันทั้งสองครั้ง หากผลพลิกเพียงเพราะลำดับ ให้ถือว่าเสมอ

นำคู่มือนี้ไปใช้กับ Ailoot

เชื่อมต่อโมเดล AI เข้ากับแอปพลิเคชัน เอเจนต์ และระบบอัตโนมัติของคุณผ่าน Ailoot API เดียว เลือกโมเดลที่เหมาะกับงาน แล้วทำตามเอกสารประกอบของ Ailootเพื่อเริ่มต้น