Jev เทียบกับโมเดลภาษา

การตัดสินใจเดียวกัน เขียนสองวิธี

จัดเส้นทางตั๋วฝ่ายสนับสนุนหนึ่งใบไปยังหนึ่งในสี่คิว นี่คือต้นทุนที่แต่ละฝั่งเรียกเก็บจากคุณในรูปของโค้ด

const res = await llm.chat({
  messages: [{ role: "user", content:
    `Route this ticket. Reply with JSON: {"queue": "Billing"|"Technical"|"Account"|"Sales"}
     Ticket: ${ticket}` }],
  response_format: { type: "json_object" }
});

let queue;
try {
  queue = JSON.parse(res.content).queue;        // may not be JSON
} catch {
  return retry();                               // ...so there is a retry
}
if (!QUEUES.includes(queue)) return retry();    // may be a queue you never had
// and no idea how close the call was

const { answers } = await jev.systemOne({
  state: ticket,
  model: "jev-latest",
  questions: { queue: { type: "choice", instructions:
    "Which team should own this ticket?", criteria: QUEUES } }
});

const { choice, probabilities, confidence } = answers.queue;
// choice is one of QUEUES. It cannot be anything else.
if (confidence < 0.7) return humanReview(ticket, probabilities);
route(choice);

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

สิ่งที่เวอร์ชันที่สองมองเห็น

ตั๋วใบนั้น รันผ่าน Jev จริง ๆ ผู้ชนะไม่น่าแปลกใจ แต่อันดับสองคือส่วนที่ป้ายเปล่า ๆ จะทิ้งไป

ฝ่ายเทคนิคชนะที่ 87% แต่ฝ่ายบัญชีถือไว้ 13% และนี่คือความไม่ลงรอยที่ถูกต้อง เพราะความล้มเหลวของ SSO นั่งอยู่บนเส้นแบ่งระหว่างสองฝ่ายจริง ๆ ป้ายเปล่า ๆ จะปิดบังเรื่องนี้ไว้ ถ้าการจัดเส้นทางผิดมีต้นทุน 13% คือตัวเลขที่ควรตั้งเกณฑ์

วางเทียบกัน

สิ่งที่คุณส่งไป

Jev

สถานะหนึ่งชุด พร้อมแผนที่ของคำถามที่มีชนิดข้อมูล

โมเดลภาษา

พรอมป์ตหนึ่งอัน ซึ่งมักแบกสคีมาและกฎเกณฑ์ไว้ในรูปร้อยแก้ว

สิ่งที่กลับมา

Jev

คำตอบที่มีชนิดข้อมูลหนึ่งคำตอบต่อหนึ่งคำถาม พร้อมความน่าจะเป็นของทุกตัวเลือก

โมเดลภาษา

ข้อความ หรือ JSON ถ้าคุณขอดี ๆ และโหมดนั้นรองรับ

โค้ดบรรทัดถัดไปของคุณ

Jev

การแตกกิ่งบนค่าที่เป็นได้เฉพาะค่าของคุณเท่านั้น

โมเดลภาษา

การแยกวิเคราะห์ แล้วการตรวจสอบความถูกต้อง แล้วกิ่งสำหรับตอนที่อย่างใดอย่างหนึ่งล้มเหลว

มันพังอย่างไร

Jev

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

โมเดลภาษา

มันผิดพลาดเรื่องรูปแบบได้ด้วย เช่น ฟิลด์หาย ป้ายที่คุณไม่เคยระบุ หรือร้อยแก้วห่อหุ้ม JSON เอาไว้

การถามสิบเรื่อง

Jev

สิบคำถามในคำขอเดียว ประเมินต่อสถานะแบบขนาน

โมเดลภาษา

พรอมป์ตเดียวที่อัดแน่น หรือเรียกสิบครั้ง

ความไม่แน่นอน

Jev

การแจกแจงและค่าความมั่นใจ บนทุก Choice และ Score

โมเดลภาษา

อะไรก็ตามที่ตัวข้อความอ้างเกี่ยวกับความแน่ใจของตัวเอง

ตัวเลข

TypeSafe เป็นผู้เผยแพร่ตัวเลขเหล่านี้ เป็นตัวเลขของผู้ให้บริการเอง ไม่ใช่การวัดของเรา

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

เมื่อไรโมเดลภาษาคือเครื่องมือที่ถูกต้อง

ส่วนใหญ่แล้ว ถ้าสิ่งที่คุณต้องการคือภาษา Jev ไม่มีความเห็นที่มันอธิบายได้ และไม่มีอะไรจะพูด

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

ทั้งสองประกอบกันได้ดีกว่าที่จะแข่งกัน กรอบคิดของ TypeSafe เองคือ System One สำหรับการตัดสินเชิงโครงสร้างที่รวดเร็ว และโมเดลทั่วไปเป็น System Two อยู่ข้างหลัง กรองอินพุตด้วย Noul จัดเส้นทางด้วย Choice แล้วส่งสิ่งที่รอดผ่านไปให้โมเดลที่เขียนได้จริง

อ่านต่อ