แอปที่ใช้ LLM ส่วนใหญ่มักเต็มไปด้วยการตัดสินใจเล็กๆ น้อยๆ: เอเจนต์ควรเรียกใช้เครื่องมือใด? ควรให้โมเดลไหนตอบคำถามนี้? ข้อความนี้ผิดนโยบายหรือไม่?
ทุกวันนี้ หลายทีมตอบคำถามเหล่านี้โดยให้โมเดลเชิงกำเนิดเขียนคำตอบเป็นข้อความ จากนั้นจึงพาร์สข้อความนั้นเพื่อนำไปสู่การตัดสินใจ
บริการ Gemini Decisions API ของ Google ใช้วิธีที่ต่างออกไป โดยใช้ โมเดล Gemini Decision 1 เพื่อให้คะแนนชุดตัวเลือกคงที่ในหนึ่งรอบการประมวลผล และส่งคืนความน่าจะเป็นของแต่ละตัวเลือก โดยไม่คิดค่าบริการโทเค็นขาออก
ในบทช่วยสอนนี้ เราจะรันงานจัดหมวดหมู่เจตนาเดียวกันบนสองรูปแบบดังนี้:
Gemini Decision 1 ผ่าน Decisions API
Gemini 3.5 Flash-Lite ผ่าน Interactions API โดยใช้ผลลัพธ์ JSON แบบมีโครง
เราจะเปรียบเทียบด้านความแม่นยำ เวลาแฝง การใช้โทเค็น ต้นทุน และการปรับเทียบความเชื่อมั่น แล้วผลักทั้งคู่นับจาก 1 เป็น 100 คำถามในคำขอเดียว
เมื่อจบบทช่วยสอนนี้ จะสามารถ:
เรียก Decisions API ด้วยคำถามแบบ choice และอ่านค่าความน่าจะเป็นกับคะแนนความเชื่อมั่น
สร้างเบสไลน์แบบเชิงกำเนิดด้วย Interactions API และสคีมา JSON
วัดเวลาแฝง การใช้โทเค็น และต้นทุนสำหรับทั้งสองแนวทาง
ตรวจสอบว่าความเชื่อมั่นของโมเดลน่าเชื่อถือหรือไม่ ด้วยไดอะแกรมความน่าเชื่อถือและค่า ECE
ตัดสินใจว่าเมื่อใดโมเดลตัดสินใจเหมาะกับแอปมากกว่าโมเดลเชิงกำเนิด
สามารถรันโค้ดครบชุดได้ใน Google Colab .
โมเดลตัดสินใจกับโมเดลเชิงกำเนิด
ก่อนดูว่าแต่ละแบบทำงานอย่างไร มานิยามทั้งสองคำกันก่อน
โมเดลเชิงกำเนิด: โมเดลนี้ผลิตคอนเทนต์ใหม่ เมื่อให้พรอมป์ต ก็จะเขียนคำตอบทีละโทเค็น คำตอบอาจเป็นได้ทั้งคำตอบ สรุป โค้ด หรือป้ายกำกับ Gemini 3.5 Flash-Lite เช่นเดียวกับ LLM ส่วนใหญ่ที่ใช้ในแอปแชต เป็นโมเดลเชิงกำเนิด
โมเดลตัดสินใจ: โมเดลตัดสินใจเลือกจากตัวเลือกที่กำหนดไว้ ให้ข้อมูลนำเข้าและรายชื่อคำตอบที่เป็นไปได้แบบคงที่ แล้วมันจะบอกความน่าจะเป็นของแต่ละตัวเลือกโดยไม่ต้องเขียนข้อความใดๆ Gemini Decision 1 เป็นโมเดลตัดสินใจ
ตัวอย่างเช่น
ลูกค้าคนหนึ่งเขียนถึงธนาคารว่า "บัตรยังมาไม่ถึง เมื่อไรจะได้?"
ถ้าถาม โมเดลเชิงกำเนิด ว่า "ลูกค้าคนนี้ต้องการอะไร?" อาจตอบว่า:
“ลูกค้ากำลังรอบัตรใหม่และอยากทราบว่าจะมาถึงเมื่อไร”
เป็นคำตอบที่ดีสำหรับมนุษย์อ่าน แต่ถ้าแอปต้องการส่งต่อข้อความไปยังทีมที่ถูกต้อง โค้ดของคุณต้องแปลงประโยคนั้นให้เป็นป้ายกำกับ สามารถบังคับให้เป็นป้ายกำกับด้วยสคีมา JSON ได้ แต่โมเดลก็ยังคงเขียนทีละโทเค็นอยู่ดี
แต่ถ้าถาม โมเดลตัดสินใจ คำถามเดียวกัน ต้องให้ตัวเลือกไว้ก่อน เช่น card_arrival, lost_or_stolen_card และ exchange_rate โมเดลจะส่งคืนความน่าจะเป็นของแต่ละตัวเลือก:
card_arrival 0.91
lost_or_stolen_card 0.06
exchange_rate 0.03ขับเคลื่อนโดย
โค้ดของคุณจึงสามารถใช้ความน่าจะเป็นนั้นได้โดยตรง เช่น ส่งต่อไปยังทีมบัตรหาก card_arrival สูงกว่าเกณฑ์ และส่งให้มนุษย์ตรวจหากไม่ถึง สรุปคือ:
โมเดลเชิงกำเนิด
โมเดลตัดสินใจ
ผลลัพธ์ที่ได้
ข้อความที่มันเขียนออกมา
ความน่าจะเป็นของแต่ละตัวเลือกที่กำหนดไว้
คำตอบที่เป็นไปได้
ปลายเปิด
ชุดคงที่
เหมาะสำหรับ
คำตอบ สรุป คำอธิบาย และการดึงข้อมูล
การส่งต่อข้อความ การเลือกเครื่องมือ การตรวจนโยบาย และการให้คะแนน
ในทางปฏิบัติ แอปจำนวนมากใช้โมเดลเชิงกำเนิดทำทั้งสองงาน ซึ่งเราจะทดสอบในส่วนถัดไปว่า โมเดลตัดสินใจทำงานจัดหมวดหมู่ได้ดีกว่าโมเดลเชิงกำเนิดหรือไม่
เมื่อใช้โมเดลเชิงกำเนิดเป็นตัวจัดหมวดหมู่ มันจะเขียนคำตอบทีละโทเค็น สำหรับคำตอบแบบ JSON อย่างของเรา เอาต์พุตขณะถูกสร้างจะมีลักษณะดังนี้:
{
{"intent":
{"intent": "card_arrival",
{"intent": "card_arrival", "confidence": 0.95}ขับเคลื่อนโดย
แต่ละโทเค็นเป็นการถอดรหัสหนึ่งรอบ และโทเค็นขาออกทุกตัวจะถูกคิดค่าบริการ หากต้องการคะแนนความเชื่อมั่น ตัวเลขนั้นก็ต้องถูกเขียนออกมาด้วย ซึ่งเป็นการคาดเดาของโมเดลเอง ไม่ใช่ความน่าจะเป็นที่วัดจากภายใน
โมเดลตัดสินใจจะข้ามขั้นตอนการเขียนนี้ ให้ตัวเลือกไว้ล่วงหน้า แล้วให้คะแนนทุกตัวเลือกกับอินพุตในหนึ่งรอบ ผลลัพธ์คือความน่าจะเป็นของทุกตัวเลือก:
card_arrival 0.12
card_delivery_estimate 0.85
lost_or_stolen_card 0.01
...ขับเคลื่อนโดย
สิ่งนี้เปลี่ยน 3 ประเด็นที่วัดได้:
เวลาแฝง : ไม่มีลูปถอดรหัส เวลาแฝงจึงไม่ควรเพิ่มตามความยาวคำตอบ
ต้นทุน : ไม่มีโทเค็นขาออกให้คิดเงิน จ่ายเฉพาะโทเค็นขาเข้า ซึ่งรวมข้อความคำถามและคำอธิบายตัวเลือก
ความเชื่อมั่น : มาจากความน่าจะเป็นโดยตรง จึงควรสอดคล้องกับความถี่ที่โมเดลตอบถูก
ข้อแลกเปลี่ยนคือถามได้เฉพาะคำถามแบบชุดปิด โมเดลตัดสินใจอธิบายคำตอบ ดึงค่า หรือเขียนข้อความอิสระไม่ได้
เดโม: สร้างตัวจัดหมวดหมู่เจตนาลูกค้าธนาคาร
ในเดโมนี้ เราจะสร้างตัวจัดหมวดหมู่เจตนาเกี่ยวกับธนาคาร ใช้ชุดทดสอบของ Banking77 ซึ่งเป็นชุดข้อมูลสาธารณะของข้อความลูกค้าที่ติดป้ายกำกับด้วย 77 เจตนา และคงไว้ 12 เจตนาที่มักสับสนกันง่าย:
card_arrival และ card_delivery_estimate
pending_card_payment, declined_card_payment และ card_payment_fee_charged
pending_transfer, transfer_not_received_by_recipient และ balance_not_updated_after_bank_transfer
lost_or_stolen_card, card_not_working, exchange_rate และ top_up_failed
เจตนาที่คล้ายกันทำให้งานยากขึ้น ทำให้คะแนนความเชื่อมั่นน่าสนใจที่จะศึกษา
เราจะรันตัวจัดหมวดหมู่ด้วยทั้งสองโมเดลในสองแบบ:
หนึ่งข้อความต่อคำขอ: 180 ข้อความ (เจตนาละ 15) ส่งให้แต่ละโมเดลทีละข้อความ
หลายคำถามต่อคำขอ: ใส่ข้อความ N ข้อความลงในอินพุตเดียว และถามหนึ่งคำถามต่อข้อความ โดย N = 1, 5, 10, 25, 50 และ 100
ตั้งค่าที่คงเหมือนกันสำหรับทั้งสองโม เดลมีดังนี้:
การตั้งค่า
ค่าที่ใช้
เหตุผล
โมเดลตัดสินใจ
gemini-decision-1
โมเดลที่ต้องการทดสอบ
โมเดลเชิงกำเนิด
gemini-3.5-flash-lite
เบสไลน์เชิงกำเนิดที่คุ้มต้นทุนซึ่งใช้ในการเปรียบเทียบตอนเปิดตัว
อุณหภูมิของ Flash-Lite
0.0
ตัดสัญญาณรบกวนจากการสุ่มออกจากเบสไลน์
ระดับการคิดของ Flash-Lite
minimal
ทำให้การเปรียบเทียบโฟกัสที่การถอดรหัส ไม่ใช่การให้เหตุผล
รูปแบบผลลัพธ์
สคีมา JSON ที่มี enum เป็น 12 ป้ายกำกับ
Flash-Lite จะส่งคืนได้เฉพาะป้ายกำกับที่ถูกต้อง
คำอธิบายตัวเลือก
หนึ่งประโยคสั้นต่อเจตนา
ทั้งสองโมเดลเห็นคำจำกัดความของป้ายเหมือนกัน
การวอร์มอัพคอล
โมเดลละ 2 ครั้ง
กันเวลาตั้งค่าการเชื่อมต่อออกจากการวัด
การทำซ้ำ (หลายคำถามต่อคำขอ)
การตั้งค่าละ 3 ครั้ง
รายงานค่ามัธยฐาน ไม่ใช่การรันครั้งเดียว
หมายเหตุ : การตั้งค่าเหล่านี้ใช้ทำงานสำหรับเดโมนี้ ไม่ใช่การปรับจูนเพื่อให้เหมาะที่สุดกับโมเดลใดๆ
ขั้นตอนที่ 1: ข้อกำหนดเบื้องต้นและการตั้งค่า
ในการทำตาม ต้องมี:
คีย์ Gemini API จาก Google AI Studio
สมุดบันทึก Colab (หรือสภาพแวดล้อม Python 3 ใดๆ)
google-genai เวอร์ชัน 3.2 ขึ้นไป
Decisions API มีโควตาทดลองแบบไม่มีค่าใช้จ่ายใน Google AI Studio จึงลองใช้ก่อนได้ รันเดโมนี้ใน Colab แต่จะใช้สภาพแวดล้อม Python 3 แบบใดก็ได้
มาเริ่มติดตั้งแพ็กเกจ:
! pip install -q -U "google-genai>=3.2" pandas matplotlibขับเคลื่อนโดย
ที่นี่ google-genai คือ SDK ภาษา Python ของ Google สำหรับ Gemini API ซึ่งให้เมธอด client.decisions.create และ client.interactions.create เพื่อส่งคำขอไปยัง Decisions API และ Interactions API ใช้ pandas โหลดชุดข้อมูลและจัดระเบียบผลลัพธ์ และใช้ matplotlib วาดกราฟ
ถัดไป สร้างไคลเอนต์ Decisions API ต้องใช้เวอร์ชัน v1beta ของ API:
import os, time, json
import numpy as np
import pandas as pd
from google import genai
client = genai. Client(
api_key= os. environ[ "GEMINI_API_KEY" ] ,
http_options= { "api_version" : "v1beta" } ,
)
DECISION_MODEL = "gemini-decision-1"
GEN_MODEL = "gemini-3.5-flash-lite" ขับเคลื่อนโดย
ที่นี่ genai.Client() อ่านคีย์ API จาก GEMINI_API_KEY ที่ตั้งไว้ใน Secrets ของ Colab หรือเป็นตัวแปรสภาพแวดล้อม และ http_options ชี้ไปที่ API เวอร์ชัน v1beta ซึ่งเป็นที่อยู่ของ Decisions API
จากนั้นโหลดชุดข้อมูล Banking77 และกำหนด 12 เจตนาของเรา โดยให้คำอธิบายหนึ่งประโยคต่อเจตนาที่ทั้งสองโมเดลจะเห็น:
BANKING77_URL = (
"https://raw.githubusercontent.com/PolyAI-LDN/task-specific-datasets/master/banking_data/test.csv"
)
INTENTS = {
"card_arrival" : "The customer is asking where their new card is or why it has not arrived yet." ,
"card_delivery_estimate" : "The customer wants to know how long card delivery usually takes." ,
"lost_or_stolen_card" : "The customer's card was lost or stolen." ,
}
LABELS = list ( INTENTS)
df = pd. read_csv( BANKING77_URL)
df = df[ df[ "category" ] . isin( LABELS) ] . reset_index( drop= True )
sample = (
df. groupby( "category" )
. sample( n= 15 , random_state= 42 )
. sample( frac= 1 , random_state= 42 )
. reset_index( drop= True )
) ขับเคลื่อนโดย
โค้ดด้านบนดาวน์โหลดชุดทดสอบ Banking77 เป็นไฟล์ CSV และคงไว้เฉพาะแถวที่ติดป้ายกำกับด้วยหนึ่งใน 12 เจตนาของเรา จากนั้นสุ่มตัวอย่างข้อความเจตนาละ 15 ข้อความด้วย seed คงที่ เพื่อให้ได้ตัวอย่างเดิมทุกครั้งที่รัน คำสั่ง .sample(frac=1) สุดท้ายจะสับลำดับแถวเพื่อผสมเจตนา
ทั้งหมดนี้ให้ข้อความ 180 ข้อความ เจตนาละ 15
ขั้นตอนที่ 2: จัดหมวดหมู่ด้วย Decisions API
คำถามแบบ choice ต้องใช้ดิกชันนารีที่แมป ID ของตัวเลือกแต่ละตัวเข้ากับคำอธิบาย เราส่งข้อความเป็น input และถามหนึ่งคำถามที่คีย์ intent:
def decide_intent ( text) :
start = time. perf_counter( )
result = client. decisions. create(
model= DECISION_MODEL,
input = text,
questions= {
"intent" : {
"type" : "choice" ,
"instructions" : "Which intent best describes this banking customer message?" ,
"criteria" : INTENTS,
}
} ,
)
latency = time. perf_counter( ) - start
ans = result. answers[ "intent" ]
return {
"pred" : ans. choice,
"confidence" : float ( ans. confidence) ,
"probabilities" : dict ( ans. probabilities) ,
"latency_s" : latency,
"input_tokens" : result. usage. total_input_tokens,
"output_tokens" : result. usage. total_output_tokens,
} ขับเคลื่อนโดย
ฟังก์ชัน decide_intent() ส่งข้อความหนึ่งข้อความเป็น input และคำถามแบบ choice หนึ่งข้อ พร้อม 12 เจตนาเป็นตัวเลือก จับเวลาเรียกด้วย time.perf_counter() จากนั้นอ่านตัวเลือกอันดับหนึ่ง ค่าความเชื่อมั่น ความน่าจะเป็นทุกตัวเลือก และจำนวนโทเค็นจากคำตอบ
แต่ละคำตอบมีสามฟิลด์:
choice: ตัวเลือกที่มีความน่าจะเป็นสูงสุด
probabilities: หนึ่งค่าความน่าจะเป็นต่อหนึ่งตัวเลือก รวมกันเท่ากับ 1
confidence: ความน่าจะเป็นโดยประมาณว่าคำตอบอันดับหนึ่งถูกต้อง
อ็อบเจ็กต์ usage รายงานโทเค็นขาเข้า และ total_output_tokens จะเป็น 0 เสมอ
ผลลัพธ์สำหรับข้อความแรกในตัวอย่างของเรามีดังนี้:
โมเดลสับสนระหว่างเจตนาที่คล้ายกัน แต่คะแนนความเชื่อมั่น 0.846 สะท้อนความไม่แน่ใจ จุดที่ดีคือเจตนาที่ถูกต้อง card_arrival มาเป็นอันดับสองด้วยความน่าจะเป็นเกือบทั้งหมดที่เหลือ (ราว 0.15) ตัวเลือกอื่นๆ ใกล้ศูนย์
ขั้นตอนที่ 3: จัดหมวดหมู่ด้วย Flash-Lite
สำหรับเบสไลน์เชิงกำเนิด เราใช้ผลลัพธ์แบบมีโครงด้วย enum ของ 12 ป้ายกำกับเดียวกัน เพื่อให้ Flash-Lite ส่งคืนได้เฉพาะป้ายกำกับที่ใช้ได้ และขอคะแนนความเชื่อมั่นระหว่าง 0 ถึง 1 ซึ่งเป็นวิธีที่แอปส่วนใหญ่ใช้เพื่อให้ได้คะแนนความเชื่อมั่นจากโมเดลเชิงกำเนิด:
LABEL_LIST = "\n" . join( f"- { k} : { v} " for k, v in INTENTS. items( ) )
GEN_SCHEMA = {
"type" : "object" ,
"properties" : {
"intent" : { "type" : "string" , "enum" : LABELS} ,
"confidence" : { "type" : "number" } ,
} ,
"required" : [ "intent" , "confidence" ] ,
}
def generate_intent ( text) :
prompt = (
"Which intent best describes this banking customer message?\n\n"
f"Intents:\n { LABEL_LIST} \n\n"
f"Message: { text} \n\n"
"Return the intent and your confidence from 0 to 1."
)
start = time. perf_counter( )
interaction = client. interactions. create(
model= GEN_MODEL,
input = prompt,
response_format= {
"type" : "text" ,
"mime_type" : "application/json" ,
"schema" : GEN_SCHEMA,
} ,
generation_config= { "temperature" : 0.0 , "thinking_level" : "minimal" } ,
store= False ,
)
latency = time. perf_counter( ) - start
parsed = json. loads( interaction. output_text)
return {
"pred" : parsed[ "intent" ] ,
"confidence" : float ( parsed[ "confidence" ] ) ,
"latency_s" : latency,
"input_tokens" : interaction. usage. total_input_tokens,
"output_tokens" : interaction. usage. total_output_tokens,
"thought_tokens" : interaction. usage. total_thought_tokens,
} ขับเคลื่อนโดย
ฟังก์ชัน generate_intent() สร้างพรอมป์ตพร้อม 12 เจตนาและคำอธิบาย เรียก Flash-Lite โดยตั้งค่า response_format เป็นสคีมา JSON ของเรา เพื่อให้เอาต์พุตต้องเป็น JSON ที่ถูกต้องและเป็นหนึ่งใน 12 ป้ายกำกับ ตั้งค่าอุณหภูมิเป็น 0 และระดับการคิด minimal เพื่อให้คำตอบนิ่งและสั้น จากนั้นพาร์ส interaction.output_text ด้วย json.loads() และอ่านจำนวนโทเค็นจาก interaction.usage
ทดสอบข้อความเดียวกับขั้นตอนก่อนหน้าด้วย Flash-Lite แล้วพบว่าผิดเหมือนกันแต่มั่นใจมากกว่า:
จำนวนโทเค็นการคิดเป็น 0 ยืนยันว่า minimal ทำให้ Flash-Lite เขียนเฉพาะคำตอบ Flash-Lite ใช้โทเค็นขาเข้าน้อยกว่า Decision 1 (277 เทียบกับ 337) เพราะ Decisions API นับคำอธิบายตัวเลือกภายในคำถามเป็นอินพุต
ขั้นตอนที่ 4: จัดหมวดหมู่แบบหนึ่งข้อความต่อคำขอ
ต่อไป ส่งทั้ง 180 ข้อความไปยังทั้งสองโมเดล ทีละคำขอ หลังจากวอร์มอัพโมเดลละสองครั้ง:
rows = [ ]
for i, r in sample. iterrows( ) :
for model_name, fn in ( ( "decision" , decide_intent) , ( "generative" , generate_intent) ) :
out = fn( r[ "text" ] )
rows. append( {
"model" : model_name, "gold" : r[ "category" ] , "pred" : out[ "pred" ] ,
"confidence" : out[ "confidence" ] , "latency_s" : out[ "latency_s" ] ,
"input_tokens" : out[ "input_tokens" ] , "output_tokens" : out[ "output_tokens" ] ,
} )
exp1 = pd. DataFrame( rows)
exp1[ "correct" ] = exp1[ "pred" ] == exp1[ "gold" ] ขับเคลื่อนโดย
ลูปนี้ส่งแต่ละข้อความให้ทั้งสองฟังก์ชัน และบันทึกการพยากรณ์ ความเชื่อมั่น เวลาแฝง และจำนวนโทเค็นเป็นหนึ่งแถว จากนั้นเปลี่ยนเป็น DataFrame และเพิ่มคอลัมน์ correct เพื่อบอกว่าการพยากรณ์ตรงกับป้ายกำกับจริงหรือไม่
ผลลัพธ์มีดังนี้:
ตัวชี้วัด
Gemini Decision 1
Gemini 3.5 Flash-Lite
ความแม่นยำ
84.4%
83.9%
เวลาแฝงมัธยฐาน
325 ms
1,068 ms
เวลาแฝง p90
412 ms
6,483 ms
คำขอที่ช้าที่สุด
1.0 s
101.6 s
คำขอเกิน 5 s
0 จาก 180
33 จาก 180
โทเค็นขาเข้าเฉลี่ย
339
279
โทเค็นขาออกเฉลี่ย
0
25
สามข้อสรุปจากตัวชี้วัดเหล่านี้คือ:
ความแม่นยำ: ทั้งสองโมเดลแม่นยำพอๆ กัน
เวลาแฝง: Decision 1 เร็วกว่าโดยราว 3 เท่าที่ค่ามัธยฐานและนิ่งกว่า ขณะที่ Flash-Lite มีหางที่ยาวของคำขอช้า
โทเค็น: Decision 1 ใช้โทเค็นขาเข้ามากกว่าเพราะนับคำอธิบายตัวเลือกเป็นอินพุต แต่ไม่มีโทเค็นขาออกเลย
หมายเหตุ : เวลาแฝงรวมการเดินทางของเครือข่ายจาก Colab ดังนั้นควรมองความต่างนี้ว่าแปรตามสภาพแวดล้อม
ขั้นตอนที่ 5: ตรวจสอบการปรับเทียบ
ความแม่นยำบอกว่าโมเดลตอบถูกบ่อยแค่ไหน แต่การปรับเทียบ (calibration) บอกว่าคะแนนความเชื่อมั่นมีความหมายหรือไม่ โมเดลถูกปรับเทียบดีเมื่อคะแนนความเชื่อมั่นสอดคล้องกับความแม่นยำ กล่าวคือ หากบอก 0.8 สำหรับกลุ่มคำตอบหนึ่งๆ ประมาณ 80% ควรจะถูกต้อง
เพื่อวัดสิ่งนี้ เราจัดกลุ่มการพยากรณ์ตาม 10 ช่วงความเชื่อมั่น แล้วเปรียบเทียบค่าเฉลี่ยความเชื่อมั่นของแต่ละช่วงกับความแม่นยำ ค่า Expected calibration error (ECE) คือช่องว่างเฉลี่ยที่ถ่วงน้ำหนักด้วยสัดส่วนของการพยากรณ์ในแต่ละช่วง ยิ่งต่ำยิ่งดี
def ece ( conf, correct, n_bins= 10 ) :
conf = np. asarray( conf, dtype= float )
correct = np. asarray( correct, dtype= float )
edges = np. linspace( 0 , 1 , n_bins + 1 )
ids = np. clip( np. digitize( conf, edges[ 1 : - 1 ] ) , 0 , n_bins - 1 )
total = 0.0
for b in range ( n_bins) :
mask = ids == b
if mask. sum ( ) :
total += mask. mean( ) * abs ( conf[ mask] . mean( ) - correct[ mask] . mean( ) )
return totalขับเคลื่อนโดย
ฟังก์ชัน ece() จัดวางการพยากรณ์แต่ละรายการลงใน 1 ใน 10 ช่วงตามความเชื่อมั่น (0–0.1, 0.1–0.2, เป็นต้น) สำหรับแต่ละช่วง จะคำนวณช่องว่างระหว่างค่าเฉลี่ยความเชื่อมั่นกับความแม่นยำ ถ่วงด้วยสัดส่วนของการพยากรณ์ในช่วงนั้น แล้วรวมผล
ผลการเปรียบเทียบของสองโม เดลเป็นดังนี้:
ตัวชี้วัด
Gemini Decision 1
Gemini 3.5 Flash-Lite
ความแม่นยำ
84.4%
83.9%
ความเชื่อมั่นเฉลี่ย
0.867
0.957
ECE
0.050
0.124
ความเชื่อมั่นเฉลี่ยเมื่อถูก
0.901
0.966
ความเชื่อมั่นเฉลี่ยเมื่อผิด
0.686
0.912
ภาพ: ไดอะแกรมความน่าเชื่อถือของทั้งสองโมเดล
ความเชื่อมั่นของ Decision 1 ใกล้เคียงกับความแม่นยำ โดยมี ECE 0.050 และต่ำลงอย่างชัดเจนเมื่อโมเดลตอบผิด (0.686) เมื่อเทียบกับตอนตอบถูก (0.901)
Flash-Lite มั่นใจเกินจริง รายงานค่าเฉลี่ย 0.957 แต่ตอบถูก 83.9% ของครั้งทั้งหมด ใช้ค่าความเชื่อมั่นเพียง 9 ค่าใน 180 คำตอบ และ 158 คำตอบอยู่ที่ 0.95 หรือสูงกว่า แม้คำตอบผิดก็เฉลี่ย 0.912 ตัวเลขดูเหมือนความน่าจะเป็น แต่จริงๆ เป็นการประเมินของโมเดลเองที่เขียนเป็นข้อความ
การปรับเทียบสำคัญเมื่อจะนำคะแนนไปใช้ปฏิบัติ รูปแบบที่พบบ่อยคือรับคำตอ บที่สูงกว่าเกณฑ์ความเชื่อมั่น และส่งที่เหลือไปยังโมเดลสำรองหรือมนุษย์:
เกณฑ์
Decision 1: สัดส่วนที่เก็บไว้
Decision 1: ความแม่นยำของที่เก็บไว้
Flash-Lite: สัดส่วนที่เก็บไว้
Flash-Lite: ความแม่นยำของที่เก็บไว้
0.50
94.4%
85.9%
99.4%
84.4%
0.70
78.3%
92.2%
98.9%
84.3%
0.80
74.4%
93.3%
98.9%
84.3%
0.90
63.3%
95.6%
88.9%
87.5%
0.95
53.9%
96.9%
87.8%
87.3%
กับ Decision 1 เมื่อเพิ่มเกณฑ์สูงขึ้นก็ทำงานตามคาด ที่ 0.9 เก็บข้อความไว้ 63% ที่ความแม่นยำ 95.6% ส่วน Flash-Lite เกณฑ์ช่วยได้น้อย เพราะคำตอบผิดส่วนใหญ่ก็มีความเชื่อมั่นสูง เอกสารทางการแนะนำให้เลือกเกณฑ์จากตัวอย่างที่ติดป้ายกำกับของทราฟฟิกจริงของคุณ
ขั้นตอนที่ 6: จัดหมวดหมู่ 100 ข้อความในคำขอเดียว
Decisions API สามารถตอบได้สูงสุด 1,000 คำถามเกี่ยวกับอินพุตร่วมหนึ่งรายการภายในคำขอเดียว เพื่อทดสอบ เราจะใส่ข้อความลูกค้า N ข้อความลงในอินพุตเดียว และถามหนึ่งคำถามต่อข้อความ
สำหรับ Decision 1 หมายถึงมีคำถามแบบ choice N ข้อ ที่คีย์ m1 ถึง mN:
def build_batch ( n) :
msgs = pool. iloc[ : n]
shared = "Banking customer messages:\n" + "" . join(
f"Message { i + 1 } : { t} \n" for i, t in enumerate ( msgs[ "text" ] )
)
return shared, list ( msgs[ "category" ] )
def decide_batch ( n) :
shared, gold = build_batch( n)
questions = {
f"m { i + 1 } " : {
"type" : "choice" ,
"instructions" : f"Which intent best describes Message { i + 1 } ?" ,
"criteria" : INTENTS,
}
for i in range ( n)
}
result = client. decisions. create(
model= DECISION_MODEL, input = shared, questions= questions
)
preds = [ result. answers[ f"m { i + 1 } " ] . choice for i in range ( n) ]
return preds, gold, result. usageขับเคลื่อนโดย
ที่นี่ build_batch() จะใส่หมายเลขให้ N ข้อความแรก แล้วรวมเป็นอินพุตเดียว จากนั้น decide_batch() สร้างคำถามแบบ choice หนึ่งข้อ ต่อหนึ่งข้อความ ที่คีย์ m1 ถึง mN ส่งทั้งหมดในคำขอเดียว และอ่านคำตอบหนึ่งรายการต่อหนึ่งคีย์
สำหรับ Flash-Lite เราส่งอินพุตร่วมชุดเดียวกันพร้อมสคีมา JSON ที่มี N ฟิลด์ โดยแต่ละฟิลด์จำกัดไว้ที่ 12 ป้ายกำกับ ใช้ข้อความชุดเดียวกันสำหรับทั้งสองโมเดลในแต่ละค่า N และแต่ละการตั้งค่ารันสามครั้ง
จำนวนคำถามต่อคำขอ
Decision 1: เวลาแฝงมัธยฐาน
Flash-Lite: เวลาแฝงมัธยฐาน
Decision 1: โทเค็นขาเข้า
Flash-Lite: โทเค็นขาเข้า / ขาออก
1
318 ms
888 ms
344
291 / 14
5
353 ms
858 ms
1,554
369 / 64
10
398 ms
1,063 ms
3,056
456 / 129
25
546 ms
2,753 ms
7,570
710 / 350
50
592 ms
ล้มเหลว
15,100
ล้มเหลว
100
59,095 ms
ล้มเหลว
30,309
ล้มเหลว
จนถึง 25 คำถาม เวลาแฝงมัธยฐานของ Decision 1 ต่ำกว่า 550 ms ส่วน Flash-Lite เพิ่มตาม N จากต่ำกว่า 1 วินาทีที่ 1 ถึง 5 คำถาม ไปเป็น 2.75 วินาทีที่ 25 คำถาม เพราะต้องเขียนคำตอบทุกข้อเป็นโทเค็นขาออก แม้ที่ 50 คำถาม มัธยฐานของ Decision 1 ยังอยู่ที่ 592 ms แม้หนึ่งในสามครั้งใช้เวลา 70 วินาที
สองประเด็นสำคัญที่ควรพิจารณา:
Flash-Lite ล้มเหลวที่ 50 และ 100 คำถาม: แถว "ล้มเหลว" ในตารางข้างต้นเป็นข้อผิดพลาด 400 แบบเดียวกัน ระบุว่าสคีมา "มีสถานะมากเกินไปสำหรับการให้บริการ" สคีมาที่มี 50 ฟิลด์ขึ้นไป โดยแต่ละฟิลด์จำกัดไว้ที่ 12 ป้ายกำกับ มากเกินกว่าที่ API ยอมรับ
Decision 1 ช้าลงที่ 100 คำถาม: แต่ละคำถามซ้ำคำอธิบายตัวเลือกทั้ง 12 รายการ ประมาณ 300 โทเค็นต่อคำถาม ทำให้คำขอถึง 30,309 โทเค็น ขณะที่คำเคลมเรื่องเวลาแฝงคงที่ของ Google ครอบคลุมบริบทไม่เกิน 16K โทเค็น
ขั้นตอนที่ 7: ลดขนาดคำขอ
คำถามที่ชัดเจนคือจะแก้ปัญหาช้าลงและล้มเหลวได้หรือไม่ สำหรับ Decision 1 เราใช้คำอธิบายตัวเลือกว่าง ("") สำหรับ Flash-Lite ขอเป็นรายชื่อป้าย N รายการแทนการมี N ฟิลด์แยกกัน:
"criteria" : { k: "" for k in LABELS}
schema = {
"type" : "object" ,
"properties" : { "intents" : {
"type" : "array" ,
"items" : { "type" : "string" , "enum" : LABELS} ,
"minItems" : n, "maxItems" : n,
} } ,
"required" : [ "intents" ] ,
} ขับเคลื่อนโดย
ผลของ Decision 1 เมื่อลดคำอธิบายเป็นค่าว่างมีดังนี้:
จำนวนคำถามต่อคำขอ
เวลาแฝงมัธยฐาน
ความแม่นยำ
โทเค็นขาเข้า
25
357 ms
84.0%
3,995
50
649 ms
78.0%
7,950
100
1,603 ms
83.0%
16,009
การตัดคำอธิบายออกช่วยลดโทเค็นขาเข้าประมาณครึ่งหนึ่ง ที่ 100 คำถาม คำขอลดลงมาเหลือประมาณ 16K โทเค็น และเวลาแฝงมัธยฐานลดจาก 59 วินาทีเหลือ 1.6 วินาที ความแม่นยำลดเล็กน้อยที่ 25 และ 50 คำถาม จึงควรใช้คำอธิบายสั้นๆ แทนที่จะไม่มีเลย โดยเฉพาะเมื่อเจตนาคล้ายกัน
สคีมารายการไม่ช่วย Flash-Lite ทำงานได้ที่ 25 คำถาม แต่ยังล้มเหลวที่ 50 และ 100
ขั้นตอนที่ 8: เปรียบเทียบต้นทุน
สุดท้าย คำนวณต้นทุนจากจำนวนโทเค็นที่แต่ละ API รายงาน โดยใช้ราคาแบบชำระเงิน:
โมเดล
ราคาโทเค็นขาเข้าต่อ 1M
ราคาโทเค็นขาออกต่อ 1M
Gemini Decision 1
$0.10
$0
Gemini 3.5 Flash-Lite
$0.30
$2.50 (รวมโทเค็นการคิด)
def cost_per_request ( model, input_tokens, output_tokens, thought_tokens) :
if model == "decision" :
return input_tokens * 0.10 / 1e6
return ( input_tokens * 0.30 + ( output_tokens + thought_tokens) * 2.50 ) / 1e6 ขับเคลื่อนโดย
ฟังก์ชัน cost_per_request() คูณจำนวนโทเค็นแต่ละประเภทด้วยราคาต่อ 1M โทเค็น สำหรับ Decision 1 นับเฉพาะโทเค็นขาเข้า สำหรับ Flash-Lite โทเค็นการคิดถูกคิดราคาตามโทเค็นขาออก จึงบวกเข้ากับโทเค็นขาออก
ต้นทุนต่อ 1,000 คำขอ ของแต่ละการตั้งค่ามีดังนี้:
การตั้งค่า
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 ข้อความต่อคำขอ
$0.034
$0.147
4.3x
5 คำถามต่อคำขอ
$0.155
$0.271
1.7x
10 คำถามต่อคำขอ
$0.306
$0.459
1.5x
25 คำถามต่อคำขอ
$0.757
$1.088
1.4x
25 คำถาม การตั้งค่าลดขนาด (ขั้นตอนที่ 7)
$0.400
$0.831
2.1x
50 คำถามต่อคำขอ
$1.510
ล้มเหลว
n/a
100 คำถาม คำอธิบายว่าง
$1.601
ล้มเหลว
n/a
สำหรับข้อความเดี่ยว Decision 1 ถูกกว่าราว 4.3 เท่า แต่ช่องว่างจะแคบลงเมื่อรวมคำถามหลายข้อในคำขอเดียว อินพุตร่วมถูกคิดครั้งเดียวในทั้งสอง API แต่แต่ละคำถามของ Decision 1 มีคำสั่งของตัวเองและคำอธิบายตัวเลือกทั้ง 12 รายการ ขณะที่ Flash-Lite เห็นรายชื่อป้ายเพียงครั้งเดียวและจ่ายค่าขาออกสั้นๆ ต่อคำตอบ ที่ 25 คำถาม Decision 1 ใช้โทเค็นขาเข้า 7,570 เทียบกับ Flash-Lite ที่ขาเข้า 710 และขาออก 350 โทเค็น
หมายเหตุ : Decisions API ไม่รองรับการแคชบริบทหรือ Batch API หากส่งอินพุตเดิมในหลายคำขอ จะถูกคิดเต็มทุกครั้ง ดังนั้นเมื่อมีหลายคำถามเกี่ยวกับอินพุตเดียวกัน ให้ถามในคำขอเดียว ไม่ใช่กระจายหลายครั้ง
ควรใช้วิธีใดเมื่อใด
จากการรันข้างต้น โมเดลตัดสินใจเหมาะกว่าเมื่อ:
คำตอบมาจากชุดตัวเลือกคงที่ เช่น เจตนา เส้นทาง เครื่องมือ หรือป้ายกำกับนโยบาย
การตัดสินใจอยู่ในเส้นทางคำขอ ซึ่งผู้ใช้ทุกคนต้องรอ
ต้องการนำค่าความเชื่อมั่นไปใช้ เช่น ส่งเคสที่ไม่ชัดเจนไปยังโมเดลสำรองหรือมนุษย์
ต้องถามคำถามอิสระหลายข้อเกี่ยวกับอินพุตเดียวกันในคำขอเดียว
โมเดลเชิงกำเนิดยังเหมาะกว่าเมื่อ:
ต้องการคำอธิบาย การดึงค่า หรือข้อความอิสระ
ชุดคำตอบเป็นปลายเปิดหรือเปลี่ยนไปตามคำขอ
ได้เรียกโมเดลเชิงกำเนิดกับอินพุตนั้นอยู่แล้ว และสามารถเพิ่มงานจัดหมวดหมู่เข้าไปได้
ใช้ Decisions API เมื่อต้องการ
ใช้ Interactions API เมื่อต้องการ
ความน่าจะเป็นแบบใช่/ไม่ใช่ ตัวเลือกหนึ่งจากชุดคงที่ หรือเรตติ้งบนสเกลคงที่
ข้อความที่สร้างขึ้น สรุป หรือคำอธิบาย
ความน่าจะเป็นที่ปรับเทียบได้และตั้งเกณฑ์ได้
ค่าที่ดึงออกมาหรืออ็อบเจ็กต์ที่เป็นไปตามสคีมา JSON ของคุณเอง
การตรวจอิสระหลายข้อเหนืออินพุตเดียวกันในหนึ่งคอล
การเรียกใช้เครื่องมือพร้อมอาร์กิวเมนต์
เวลาแฝงต่ำและไม่มีต้นทุนโทเค็นขาออก
การให้เหตุผลหลายขั้นตอน
ข้อคิดส่งท้าย
ในบทช่วยสอนนี้ เราสร้างตัวจัดหมวดหมู่เจตนาธนาคารด้วย Gemini Decision 1 และ Gemini 3.5 Flash-Lite แล้วคำนวณความแม่นยำ เวลาแฝง การปรับเทียบ และต้นทุนเพื่อเปรียบเทียบสองโมเดล สี่ข้อสรุปคือ:
ความแม่นยำสูสีกัน: Decision 1 ได้ 84.4% และ Flash-Lite ได้ 83.9% และให้คำตัดสินเดียวกันใน 163 จาก 180 ข้อความ
Decision 1 เร็วกว่าและคาดเดาได้มากกว่า: เวลาแฝงมัธยฐาน 325 ms เทียบกับ 1,068 ms และคำขอที่ช้าที่สุด 1.0 s เทียบกับ 101.6 s
ความเชื่อมั่นของ Decision 1 ใช้งานได้จริง: ECE เท่ากับ 0.050 เทียบกับ 0.124 และเมื่อยกเกณฑ์เป็น 0.9 ความแม่นยำของคำตอบที่เก็บไว้เพิ่มจาก 84.4% เป็น 95.6% ส่วนความเชื่อมั่นที่ Flash-Lite รายงานเองแยกคำตอบถูกกับผิดได้ไม่มาก
ต้นทุนและการสเกลขึ้นอยู่กับวิธีเขียนคำถาม: Decision 1 ถูกกว่าประมาณ 4.3 เท่าบนข้อความเดี่ยว แต่แต่ละคำถามต้องจ่ายค่าคำอธิบายตัวเลือก ดังนั้นควรรักษาอินพุตรวมให้อยู่ใต้ราว 16K โทเค็น และทำคำอธิบายตัวเลือกให้สั้น
ผลลัพธ์เหล่านี้มาจากงานเดียว ชุดข้อมูลเดียว และการรันจำนวนไม่มากจากสมุด Colab ควรมองเป็นข้อสังเกตจากเดโม ไม่ใช่คำอ้างด้านประสิทธิภาพทั่วไป
แอปที่ใช้ LLM ส่วนใหญ่มักเต็มไปด้วยการตัดสินใจเล็กๆ น้อยๆ: เอเจนต์ควรเรียกใช้เครื่องมือใด? ควรให้โมเดลไหนตอบคำถามนี้? ข้อความนี้ผิดนโยบายหรือไม่?
ทุกวันนี้ หลายทีมตอบคำถามเหล่านี้โดยให้โมเดลเชิงกำเนิดเขียนคำตอบเป็นข้อความ จากนั้นจึงพาร์สข้อความนั้นเพื่อนำไปสู่การตัดสินใจ
บริการ Gemini Decisions API ของ Google ใช้วิธีที่ต่างออกไป โดยใช้โมเดล Gemini Decision 1 เพื่อให้คะแนนชุดตัวเลือกคงที่ในหนึ่งรอบการประมวลผล และส่งคืนความน่าจะเป็นของแต่ละตัวเลือก โดยไม่คิดค่าบริการโทเค็นขาออก
ในบทช่วยสอนนี้ เราจะรันงานจัดหมวดหมู่เจตนาเดียวกันบนสองรูปแบบดังนี้:
เราจะเปรียบเทียบด้านความแม่นยำ เวลาแฝง การใช้โทเค็น ต้นทุน และการปรับเทียบความเชื่อมั่น แล้วผลักทั้งคู่นับจาก 1 เป็น 100 คำถามในคำขอเดียว
เมื่อจบบทช่วยสอนนี้ จะสามารถ:
เรียก Decisions API ด้วยคำถามแบบ
choiceและอ่านค่าความน่าจะเป็นกับคะแนนความเชื่อมั่นสร้างเบสไลน์แบบเชิงกำเนิดด้วย Interactions API และสคีมา JSON
วัดเวลาแฝง การใช้โทเค็น และต้นทุนสำหรับทั้งสองแนวทาง
ตรวจสอบว่าความเชื่อมั่นของโมเดลน่าเชื่อถือหรือไม่ ด้วยไดอะแกรมความน่าเชื่อถือและค่า ECE
ตัดสินใจว่าเมื่อใดโมเดลตัดสินใจเหมาะกับแอปมากกว่าโมเดลเชิงกำเนิด
สามารถรันโค้ดครบชุดได้ใน Google Colab.
โมเดลตัดสินใจกับโมเดลเชิงกำเนิด
ก่อนดูว่าแต่ละแบบทำงานอย่างไร มานิยามทั้งสองคำกันก่อน
ตัวอย่างเช่น
ลูกค้าคนหนึ่งเขียนถึงธนาคารว่า "บัตรยังมาไม่ถึง เมื่อไรจะได้?"
ถ้าถามโมเดลเชิงกำเนิด ว่า "ลูกค้าคนนี้ต้องการอะไร?" อาจตอบว่า:
“ลูกค้ากำลังรอบัตรใหม่และอยากทราบว่าจะมาถึงเมื่อไร”
เป็นคำตอบที่ดีสำหรับมนุษย์อ่าน แต่ถ้าแอปต้องการส่งต่อข้อความไปยังทีมที่ถูกต้อง โค้ดของคุณต้องแปลงประโยคนั้นให้เป็นป้ายกำกับ สามารถบังคับให้เป็นป้ายกำกับด้วยสคีมา JSON ได้ แต่โมเดลก็ยังคงเขียนทีละโทเค็นอยู่ดี
แต่ถ้าถามโมเดลตัดสินใจ คำถามเดียวกัน ต้องให้ตัวเลือกไว้ก่อน เช่น
card_arrival,lost_or_stolen_cardและexchange_rateโมเดลจะส่งคืนความน่าจะเป็นของแต่ละตัวเลือก:โค้ดของคุณจึงสามารถใช้ความน่าจะเป็นนั้นได้โดยตรง เช่น ส่งต่อไปยังทีมบัตรหาก
card_arrivalสูงกว่าเกณฑ์ และส่งให้มนุษย์ตรวจหากไม่ถึง สรุปคือ:โมเดลเชิงกำเนิด
โมเดลตัดสินใจ
ผลลัพธ์ที่ได้
ข้อความที่มันเขียนออกมา
ความน่าจะเป็นของแต่ละตัวเลือกที่กำหนดไว้
คำตอบที่เป็นไปได้
ปลายเปิด
ชุดคงที่
เหมาะสำหรับ
คำตอบ สรุป คำอธิบาย และการดึงข้อมูล
การส่งต่อข้อความ การเลือกเครื่องมือ การตรวจนโยบาย และการให้คะแนน
ในทางปฏิบัติ แอปจำนวนมากใช้โมเดลเชิงกำเนิดทำทั้งสองงาน ซึ่งเราจะทดสอบในส่วนถัดไปว่า โมเดลตัดสินใจทำงานจัดหมวดหมู่ได้ดีกว่าโมเดลเชิงกำเนิดหรือไม่
เมื่อใช้โมเดลเชิงกำเนิดเป็นตัวจัดหมวดหมู่ มันจะเขียนคำตอบทีละโทเค็น สำหรับคำตอบแบบ JSON อย่างของเรา เอาต์พุตขณะถูกสร้างจะมีลักษณะดังนี้:
แต่ละโทเค็นเป็นการถอดรหัสหนึ่งรอบ และโทเค็นขาออกทุกตัวจะถูกคิดค่าบริการ หากต้องการคะแนนความเชื่อมั่น ตัวเลขนั้นก็ต้องถูกเขียนออกมาด้วย ซึ่งเป็นการคาดเดาของโมเดลเอง ไม่ใช่ความน่าจะเป็นที่วัดจากภายใน
โมเดลตัดสินใจจะข้ามขั้นตอนการเขียนนี้ ให้ตัวเลือกไว้ล่วงหน้า แล้วให้คะแนนทุกตัวเลือกกับอินพุตในหนึ่งรอบ ผลลัพธ์คือความน่าจะเป็นของทุกตัวเลือก:
สิ่งนี้เปลี่ยน 3 ประเด็นที่วัดได้:
ข้อแลกเปลี่ยนคือถามได้เฉพาะคำถามแบบชุดปิด โมเดลตัดสินใจอธิบายคำตอบ ดึงค่า หรือเขียนข้อความอิสระไม่ได้
เดโม: สร้างตัวจัดหมวดหมู่เจตนาลูกค้าธนาคาร
ในเดโมนี้ เราจะสร้างตัวจัดหมวดหมู่เจตนาเกี่ยวกับธนาคาร ใช้ชุดทดสอบของ Banking77 ซึ่งเป็นชุดข้อมูลสาธารณะของข้อความลูกค้าที่ติดป้ายกำกับด้วย 77 เจตนา และคงไว้ 12 เจตนาที่มักสับสนกันง่าย:
card_arrivalและcard_delivery_estimatepending_card_payment,declined_card_paymentและcard_payment_fee_chargedpending_transfer,transfer_not_received_by_recipientและbalance_not_updated_after_bank_transferlost_or_stolen_card,card_not_working,exchange_rateและtop_up_failedเจตนาที่คล้ายกันทำให้งานยากขึ้น ทำให้คะแนนความเชื่อมั่นน่าสนใจที่จะศึกษา
เราจะรันตัวจัดหมวดหมู่ด้วยทั้งสองโมเดลในสองแบบ:
ตั้งค่าที่คงเหมือนกันสำหรับทั้งสองโมเดลมีดังนี้:
การตั้งค่า
ค่าที่ใช้
เหตุผล
โมเดลตัดสินใจ
gemini-decision-1โมเดลที่ต้องการทดสอบ
โมเดลเชิงกำเนิด
gemini-3.5-flash-liteเบสไลน์เชิงกำเนิดที่คุ้มต้นทุนซึ่งใช้ในการเปรียบเทียบตอนเปิดตัว
อุณหภูมิของ Flash-Lite
0.0
ตัดสัญญาณรบกวนจากการสุ่มออกจากเบสไลน์
ระดับการคิดของ Flash-Lite
minimalทำให้การเปรียบเทียบโฟกัสที่การถอดรหัส ไม่ใช่การให้เหตุผล
รูปแบบผลลัพธ์
สคีมา JSON ที่มี
enumเป็น 12 ป้ายกำกับFlash-Lite จะส่งคืนได้เฉพาะป้ายกำกับที่ถูกต้อง
คำอธิบายตัวเลือก
หนึ่งประโยคสั้นต่อเจตนา
ทั้งสองโมเดลเห็นคำจำกัดความของป้ายเหมือนกัน
การวอร์มอัพคอล
โมเดลละ 2 ครั้ง
กันเวลาตั้งค่าการเชื่อมต่อออกจากการวัด
การทำซ้ำ (หลายคำถามต่อคำขอ)
การตั้งค่าละ 3 ครั้ง
รายงานค่ามัธยฐาน ไม่ใช่การรันครั้งเดียว
หมายเหตุ: การตั้งค่าเหล่านี้ใช้ทำงานสำหรับเดโมนี้ ไม่ใช่การปรับจูนเพื่อให้เหมาะที่สุดกับโมเดลใดๆ
ขั้นตอนที่ 1: ข้อกำหนดเบื้องต้นและการตั้งค่า
ในการทำตาม ต้องมี:
คีย์ Gemini API จาก Google AI Studio
สมุดบันทึก Colab (หรือสภาพแวดล้อม Python 3 ใดๆ)
google-genaiเวอร์ชัน 3.2 ขึ้นไปDecisions API มีโควตาทดลองแบบไม่มีค่าใช้จ่ายใน Google AI Studio จึงลองใช้ก่อนได้ รันเดโมนี้ใน Colab แต่จะใช้สภาพแวดล้อม Python 3 แบบใดก็ได้
มาเริ่มติดตั้งแพ็กเกจ:
ที่นี่
google-genaiคือ SDK ภาษา Python ของ Google สำหรับ Gemini API ซึ่งให้เมธอดclient.decisions.createและclient.interactions.createเพื่อส่งคำขอไปยัง Decisions API และ Interactions API ใช้pandasโหลดชุดข้อมูลและจัดระเบียบผลลัพธ์ และใช้matplotlibวาดกราฟถัดไป สร้างไคลเอนต์ Decisions API ต้องใช้เวอร์ชัน v1beta ของ API:
ที่นี่
genai.Client()อ่านคีย์ API จากGEMINI_API_KEYที่ตั้งไว้ใน Secrets ของ Colab หรือเป็นตัวแปรสภาพแวดล้อม และhttp_optionsชี้ไปที่ API เวอร์ชัน v1beta ซึ่งเป็นที่อยู่ของ Decisions APIจากนั้นโหลดชุดข้อมูล Banking77 และกำหนด 12 เจตนาของเรา โดยให้คำอธิบายหนึ่งประโยคต่อเจตนาที่ทั้งสองโมเดลจะเห็น:
โค้ดด้านบนดาวน์โหลดชุดทดสอบ Banking77 เป็นไฟล์ CSV และคงไว้เฉพาะแถวที่ติดป้ายกำกับด้วยหนึ่งใน 12 เจตนาของเรา จากนั้นสุ่มตัวอย่างข้อความเจตนาละ 15 ข้อความด้วย seed คงที่ เพื่อให้ได้ตัวอย่างเดิมทุกครั้งที่รัน คำสั่ง
.sample(frac=1)สุดท้ายจะสับลำดับแถวเพื่อผสมเจตนาทั้งหมดนี้ให้ข้อความ 180 ข้อความ เจตนาละ 15
ขั้นตอนที่ 2: จัดหมวดหมู่ด้วย Decisions API
คำถามแบบ
choiceต้องใช้ดิกชันนารีที่แมป ID ของตัวเลือกแต่ละตัวเข้ากับคำอธิบาย เราส่งข้อความเป็นinputและถามหนึ่งคำถามที่คีย์intent:ฟังก์ชัน
decide_intent()ส่งข้อความหนึ่งข้อความเป็นinputและคำถามแบบchoiceหนึ่งข้อ พร้อม 12 เจตนาเป็นตัวเลือก จับเวลาเรียกด้วยtime.perf_counter()จากนั้นอ่านตัวเลือกอันดับหนึ่ง ค่าความเชื่อมั่น ความน่าจะเป็นทุกตัวเลือก และจำนวนโทเค็นจากคำตอบแต่ละคำตอบมีสามฟิลด์:
choice: ตัวเลือกที่มีความน่าจะเป็นสูงสุดprobabilities: หนึ่งค่าความน่าจะเป็นต่อหนึ่งตัวเลือก รวมกันเท่ากับ 1confidence: ความน่าจะเป็นโดยประมาณว่าคำตอบอันดับหนึ่งถูกต้องอ็อบเจ็กต์
usageรายงานโทเค็นขาเข้า และtotal_output_tokensจะเป็น 0 เสมอผลลัพธ์สำหรับข้อความแรกในตัวอย่างของเรามีดังนี้:
โมเดลสับสนระหว่างเจตนาที่คล้ายกัน แต่คะแนนความเชื่อมั่น 0.846 สะท้อนความไม่แน่ใจ จุดที่ดีคือเจตนาที่ถูกต้อง
card_arrivalมาเป็นอันดับสองด้วยความน่าจะเป็นเกือบทั้งหมดที่เหลือ (ราว 0.15) ตัวเลือกอื่นๆ ใกล้ศูนย์ขั้นตอนที่ 3: จัดหมวดหมู่ด้วย Flash-Lite
สำหรับเบสไลน์เชิงกำเนิด เราใช้ผลลัพธ์แบบมีโครงด้วย
enumของ 12 ป้ายกำกับเดียวกัน เพื่อให้ Flash-Lite ส่งคืนได้เฉพาะป้ายกำกับที่ใช้ได้ และขอคะแนนความเชื่อมั่นระหว่าง 0 ถึง 1 ซึ่งเป็นวิธีที่แอปส่วนใหญ่ใช้เพื่อให้ได้คะแนนความเชื่อมั่นจากโมเดลเชิงกำเนิด:ฟังก์ชัน
generate_intent()สร้างพรอมป์ตพร้อม 12 เจตนาและคำอธิบาย เรียก Flash-Lite โดยตั้งค่าresponse_formatเป็นสคีมา JSON ของเรา เพื่อให้เอาต์พุตต้องเป็น JSON ที่ถูกต้องและเป็นหนึ่งใน 12 ป้ายกำกับ ตั้งค่าอุณหภูมิเป็น0และระดับการคิดminimalเพื่อให้คำตอบนิ่งและสั้น จากนั้นพาร์สinteraction.output_textด้วยjson.loads()และอ่านจำนวนโทเค็นจากinteraction.usageทดสอบข้อความเดียวกับขั้นตอนก่อนหน้าด้วย Flash-Lite แล้วพบว่าผิดเหมือนกันแต่มั่นใจมากกว่า:
จำนวนโทเค็นการคิดเป็น 0 ยืนยันว่า
minimalทำให้ Flash-Lite เขียนเฉพาะคำตอบ Flash-Lite ใช้โทเค็นขาเข้าน้อยกว่า Decision 1 (277 เทียบกับ 337) เพราะ Decisions API นับคำอธิบายตัวเลือกภายในคำถามเป็นอินพุตขั้นตอนที่ 4: จัดหมวดหมู่แบบหนึ่งข้อความต่อคำขอ
ต่อไป ส่งทั้ง 180 ข้อความไปยังทั้งสองโมเดล ทีละคำขอ หลังจากวอร์มอัพโมเดลละสองครั้ง:
ลูปนี้ส่งแต่ละข้อความให้ทั้งสองฟังก์ชัน และบันทึกการพยากรณ์ ความเชื่อมั่น เวลาแฝง และจำนวนโทเค็นเป็นหนึ่งแถว จากนั้นเปลี่ยนเป็น DataFrame และเพิ่มคอลัมน์ correct เพื่อบอกว่าการพยากรณ์ตรงกับป้ายกำกับจริงหรือไม่
ผลลัพธ์มีดังนี้:
ตัวชี้วัด
Gemini Decision 1
Gemini 3.5 Flash-Lite
ความแม่นยำ
84.4%
83.9%
เวลาแฝงมัธยฐาน
325 ms
1,068 ms
เวลาแฝง p90
412 ms
6,483 ms
คำขอที่ช้าที่สุด
1.0 s
101.6 s
คำขอเกิน 5 s
0 จาก 180
33 จาก 180
โทเค็นขาเข้าเฉลี่ย
339
279
โทเค็นขาออกเฉลี่ย
0
25
สามข้อสรุปจากตัวชี้วัดเหล่านี้คือ:
หมายเหตุ: เวลาแฝงรวมการเดินทางของเครือข่ายจาก Colab ดังนั้นควรมองความต่างนี้ว่าแปรตามสภาพแวดล้อม
ขั้นตอนที่ 5: ตรวจสอบการปรับเทียบ
ความแม่นยำบอกว่าโมเดลตอบถูกบ่อยแค่ไหน แต่การปรับเทียบ (calibration) บอกว่าคะแนนความเชื่อมั่นมีความหมายหรือไม่ โมเดลถูกปรับเทียบดีเมื่อคะแนนความเชื่อมั่นสอดคล้องกับความแม่นยำ กล่าวคือ หากบอก 0.8 สำหรับกลุ่มคำตอบหนึ่งๆ ประมาณ 80% ควรจะถูกต้อง
เพื่อวัดสิ่งนี้ เราจัดกลุ่มการพยากรณ์ตาม 10 ช่วงความเชื่อมั่น แล้วเปรียบเทียบค่าเฉลี่ยความเชื่อมั่นของแต่ละช่วงกับความแม่นยำ ค่า Expected calibration error (ECE) คือช่องว่างเฉลี่ยที่ถ่วงน้ำหนักด้วยสัดส่วนของการพยากรณ์ในแต่ละช่วง ยิ่งต่ำยิ่งดี
ฟังก์ชัน
ece()จัดวางการพยากรณ์แต่ละรายการลงใน 1 ใน 10 ช่วงตามความเชื่อมั่น (0–0.1, 0.1–0.2, เป็นต้น) สำหรับแต่ละช่วง จะคำนวณช่องว่างระหว่างค่าเฉลี่ยความเชื่อมั่นกับความแม่นยำ ถ่วงด้วยสัดส่วนของการพยากรณ์ในช่วงนั้น แล้วรวมผลผลการเปรียบเทียบของสองโมเดลเป็นดังนี้:
ตัวชี้วัด
Gemini Decision 1
Gemini 3.5 Flash-Lite
ความแม่นยำ
84.4%
83.9%
ความเชื่อมั่นเฉลี่ย
0.867
0.957
ECE
0.050
0.124
ความเชื่อมั่นเฉลี่ยเมื่อถูก
0.901
0.966
ความเชื่อมั่นเฉลี่ยเมื่อผิด
0.686
0.912
ภาพ: ไดอะแกรมความน่าเชื่อถือของทั้งสองโมเดล
ความเชื่อมั่นของ Decision 1 ใกล้เคียงกับความแม่นยำ โดยมี ECE 0.050 และต่ำลงอย่างชัดเจนเมื่อโมเดลตอบผิด (0.686) เมื่อเทียบกับตอนตอบถูก (0.901)
Flash-Lite มั่นใจเกินจริง รายงานค่าเฉลี่ย 0.957 แต่ตอบถูก 83.9% ของครั้งทั้งหมด ใช้ค่าความเชื่อมั่นเพียง 9 ค่าใน 180 คำตอบ และ 158 คำตอบอยู่ที่ 0.95 หรือสูงกว่า แม้คำตอบผิดก็เฉลี่ย 0.912 ตัวเลขดูเหมือนความน่าจะเป็น แต่จริงๆ เป็นการประเมินของโมเดลเองที่เขียนเป็นข้อความ
การปรับเทียบสำคัญเมื่อจะนำคะแนนไปใช้ปฏิบัติ รูปแบบที่พบบ่อยคือรับคำตอบที่สูงกว่าเกณฑ์ความเชื่อมั่น และส่งที่เหลือไปยังโมเดลสำรองหรือมนุษย์:
เกณฑ์
Decision 1: สัดส่วนที่เก็บไว้
Decision 1: ความแม่นยำของที่เก็บไว้
Flash-Lite: สัดส่วนที่เก็บไว้
Flash-Lite: ความแม่นยำของที่เก็บไว้
0.50
94.4%
85.9%
99.4%
84.4%
0.70
78.3%
92.2%
98.9%
84.3%
0.80
74.4%
93.3%
98.9%
84.3%
0.90
63.3%
95.6%
88.9%
87.5%
0.95
53.9%
96.9%
87.8%
87.3%
กับ Decision 1 เมื่อเพิ่มเกณฑ์สูงขึ้นก็ทำงานตามคาด ที่ 0.9 เก็บข้อความไว้ 63% ที่ความแม่นยำ 95.6% ส่วน Flash-Lite เกณฑ์ช่วยได้น้อย เพราะคำตอบผิดส่วนใหญ่ก็มีความเชื่อมั่นสูง เอกสารทางการแนะนำให้เลือกเกณฑ์จากตัวอย่างที่ติดป้ายกำกับของทราฟฟิกจริงของคุณ
ขั้นตอนที่ 6: จัดหมวดหมู่ 100 ข้อความในคำขอเดียว
Decisions API สามารถตอบได้สูงสุด 1,000 คำถามเกี่ยวกับอินพุตร่วมหนึ่งรายการภายในคำขอเดียว เพื่อทดสอบ เราจะใส่ข้อความลูกค้า N ข้อความลงในอินพุตเดียว และถามหนึ่งคำถามต่อข้อความ
สำหรับ Decision 1 หมายถึงมีคำถามแบบ
choiceN ข้อ ที่คีย์m1ถึงmN:ที่นี่
build_batch()จะใส่หมายเลขให้ N ข้อความแรก แล้วรวมเป็นอินพุตเดียว จากนั้นdecide_batch()สร้างคำถามแบบchoiceหนึ่งข้อ ต่อหนึ่งข้อความ ที่คีย์m1ถึงmNส่งทั้งหมดในคำขอเดียว และอ่านคำตอบหนึ่งรายการต่อหนึ่งคีย์สำหรับ Flash-Lite เราส่งอินพุตร่วมชุดเดียวกันพร้อมสคีมา JSON ที่มี N ฟิลด์ โดยแต่ละฟิลด์จำกัดไว้ที่ 12 ป้ายกำกับ ใช้ข้อความชุดเดียวกันสำหรับทั้งสองโมเดลในแต่ละค่า N และแต่ละการตั้งค่ารันสามครั้ง
จำนวนคำถามต่อคำขอ
Decision 1: เวลาแฝงมัธยฐาน
Flash-Lite: เวลาแฝงมัธยฐาน
Decision 1: โทเค็นขาเข้า
Flash-Lite: โทเค็นขาเข้า / ขาออก
1
318 ms
888 ms
344
291 / 14
5
353 ms
858 ms
1,554
369 / 64
10
398 ms
1,063 ms
3,056
456 / 129
25
546 ms
2,753 ms
7,570
710 / 350
50
592 ms
ล้มเหลว
15,100
ล้มเหลว
100
59,095 ms
ล้มเหลว
30,309
ล้มเหลว
จนถึง 25 คำถาม เวลาแฝงมัธยฐานของ Decision 1 ต่ำกว่า 550 ms ส่วน Flash-Lite เพิ่มตาม N จากต่ำกว่า 1 วินาทีที่ 1 ถึง 5 คำถาม ไปเป็น 2.75 วินาทีที่ 25 คำถาม เพราะต้องเขียนคำตอบทุกข้อเป็นโทเค็นขาออก แม้ที่ 50 คำถาม มัธยฐานของ Decision 1 ยังอยู่ที่ 592 ms แม้หนึ่งในสามครั้งใช้เวลา 70 วินาที
สองประเด็นสำคัญที่ควรพิจารณา:
ขั้นตอนที่ 7: ลดขนาดคำขอ
คำถามที่ชัดเจนคือจะแก้ปัญหาช้าลงและล้มเหลวได้หรือไม่ สำหรับ Decision 1 เราใช้คำอธิบายตัวเลือกว่าง ("") สำหรับ Flash-Lite ขอเป็นรายชื่อป้าย N รายการแทนการมี N ฟิลด์แยกกัน:
ผลของ Decision 1 เมื่อลดคำอธิบายเป็นค่าว่างมีดังนี้:
จำนวนคำถามต่อคำขอ
เวลาแฝงมัธยฐาน
ความแม่นยำ
โทเค็นขาเข้า
25
357 ms
84.0%
3,995
50
649 ms
78.0%
7,950
100
1,603 ms
83.0%
16,009
การตัดคำอธิบายออกช่วยลดโทเค็นขาเข้าประมาณครึ่งหนึ่ง ที่ 100 คำถาม คำขอลดลงมาเหลือประมาณ 16K โทเค็น และเวลาแฝงมัธยฐานลดจาก 59 วินาทีเหลือ 1.6 วินาที ความแม่นยำลดเล็กน้อยที่ 25 และ 50 คำถาม จึงควรใช้คำอธิบายสั้นๆ แทนที่จะไม่มีเลย โดยเฉพาะเมื่อเจตนาคล้ายกัน
สคีมารายการไม่ช่วย Flash-Lite ทำงานได้ที่ 25 คำถาม แต่ยังล้มเหลวที่ 50 และ 100
ขั้นตอนที่ 8: เปรียบเทียบต้นทุน
สุดท้าย คำนวณต้นทุนจากจำนวนโทเค็นที่แต่ละ API รายงาน โดยใช้ราคาแบบชำระเงิน:
โมเดล
ราคาโทเค็นขาเข้าต่อ 1M
ราคาโทเค็นขาออกต่อ 1M
Gemini Decision 1
$0.10
$0
Gemini 3.5 Flash-Lite
$0.30
$2.50 (รวมโทเค็นการคิด)
ฟังก์ชัน
cost_per_request()คูณจำนวนโทเค็นแต่ละประเภทด้วยราคาต่อ 1M โทเค็น สำหรับ Decision 1 นับเฉพาะโทเค็นขาเข้า สำหรับ Flash-Lite โทเค็นการคิดถูกคิดราคาตามโทเค็นขาออก จึงบวกเข้ากับโทเค็นขาออกต้นทุนต่อ 1,000 คำขอของแต่ละการตั้งค่ามีดังนี้:
การตั้งค่า
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 ข้อความต่อคำขอ
$0.034
$0.147
4.3x
5 คำถามต่อคำขอ
$0.155
$0.271
1.7x
10 คำถามต่อคำขอ
$0.306
$0.459
1.5x
25 คำถามต่อคำขอ
$0.757
$1.088
1.4x
25 คำถาม การตั้งค่าลดขนาด (ขั้นตอนที่ 7)
$0.400
$0.831
2.1x
50 คำถามต่อคำขอ
$1.510
ล้มเหลว
n/a
100 คำถาม คำอธิบายว่าง
$1.601
ล้มเหลว
n/a
สำหรับข้อความเดี่ยว Decision 1 ถูกกว่าราว 4.3 เท่า แต่ช่องว่างจะแคบลงเมื่อรวมคำถามหลายข้อในคำขอเดียว อินพุตร่วมถูกคิดครั้งเดียวในทั้งสอง API แต่แต่ละคำถามของ Decision 1 มีคำสั่งของตัวเองและคำอธิบายตัวเลือกทั้ง 12 รายการ ขณะที่ Flash-Lite เห็นรายชื่อป้ายเพียงครั้งเดียวและจ่ายค่าขาออกสั้นๆ ต่อคำตอบ ที่ 25 คำถาม Decision 1 ใช้โทเค็นขาเข้า 7,570 เทียบกับ Flash-Lite ที่ขาเข้า 710 และขาออก 350 โทเค็น
หมายเหตุ: Decisions API ไม่รองรับการแคชบริบทหรือ Batch API หากส่งอินพุตเดิมในหลายคำขอ จะถูกคิดเต็มทุกครั้ง ดังนั้นเมื่อมีหลายคำถามเกี่ยวกับอินพุตเดียวกัน ให้ถามในคำขอเดียว ไม่ใช่กระจายหลายครั้ง
ควรใช้วิธีใดเมื่อใด
จากการรันข้างต้น โมเดลตัดสินใจเหมาะกว่าเมื่อ:
โมเดลเชิงกำเนิดยังเหมาะกว่าเมื่อ:
ใช้ Decisions API เมื่อต้องการ
ใช้ Interactions API เมื่อต้องการ
ความน่าจะเป็นแบบใช่/ไม่ใช่ ตัวเลือกหนึ่งจากชุดคงที่ หรือเรตติ้งบนสเกลคงที่
ข้อความที่สร้างขึ้น สรุป หรือคำอธิบาย
ความน่าจะเป็นที่ปรับเทียบได้และตั้งเกณฑ์ได้
ค่าที่ดึงออกมาหรืออ็อบเจ็กต์ที่เป็นไปตามสคีมา JSON ของคุณเอง
การตรวจอิสระหลายข้อเหนืออินพุตเดียวกันในหนึ่งคอล
การเรียกใช้เครื่องมือพร้อมอาร์กิวเมนต์
เวลาแฝงต่ำและไม่มีต้นทุนโทเค็นขาออก
การให้เหตุผลหลายขั้นตอน
ข้อคิดส่งท้าย
ในบทช่วยสอนนี้ เราสร้างตัวจัดหมวดหมู่เจตนาธนาคารด้วย Gemini Decision 1 และ Gemini 3.5 Flash-Lite แล้วคำนวณความแม่นยำ เวลาแฝง การปรับเทียบ และต้นทุนเพื่อเปรียบเทียบสองโมเดล สี่ข้อสรุปคือ:
ผลลัพธ์เหล่านี้มาจากงานเดียว ชุดข้อมูลเดียว และการรันจำนวนไม่มากจากสมุด Colab ควรมองเป็นข้อสังเกตจากเดโม ไม่ใช่คำอ้างด้านประสิทธิภาพทั่วไป