ข้ามไปยังเนื้อหาหลัก

Gemini Decisions API: ทดสอบโมเดลตัดสินใจตัวใหม่ของ Google ด้านเวลาแฝงและต้นทุน

เรียนรู้ว่า Gemini Decision 1 ให้คะแนนตัวเลือกคงที่ได้โดยไม่ต้องสร้างข้อความ สร้างตัวจัดหมวดหมู่เจตนาธนาคารด้วย Decisions API และเปรียบเทียบกับ Gemini 3.5 Flash-Lite ในด้านความแม่นยำ เวลาแฝง การปรับเทียบ และต้นทุน
· 15 นาที อ่าน

สำรวจด้วย AI

แอปที่ใช้ 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.",
    # ... 9 more intents
}
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 ฟิลด์แยกกัน:

# Decision 1: option IDs only, no descriptions
"criteria": {k: "" for k in LABELS}

# Flash-Lite: one list field instead of N fields
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 ควรมองเป็นข้อสังเกตจากเดโม ไม่ใช่คำอ้างด้านประสิทธิภาพทั่วไป 

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

Decisions API ต่างจาก API เชิงกำเนิดอย่างไร?

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

Gemini Decision 1 แม่นยำกว่า Gemini 3.5 Flash-Lite หรือไม่?

ไม่ ในการทดสอบของเรา บนข้อความธนาคาร 180 ข้อความ Decision 1 มีความแม่นยำ 84.4% และ Flash-Lite มี 83.9% ความต่างที่วัดได้อยู่ที่เวลาแฝง การปรับเทียบ และต้นทุน

เหตุใด Decision 1 จึงใช้โทเค็นขาเข้ามากกว่า Flash-Lite?

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

เวลาแฝงจะคงที่เมื่อเพิ่มคำถามมากขึ้นหรือไม่?

จากการรันของเรา ค่ามัธยฐานยังต่ำกว่า 650 ms จนถึง 50 คำถาม ที่ 100 คำถามพร้อมคำอธิบายเต็ม คำขอมีราว 30K โทเค็นและใช้เวลา 48 ถึง 59 วินาที เมื่อใช้คำอธิบายว่าง 100 คำถามพอดีในประมาณ 16K โทเค็นและใช้เวลา 1.6 วินาที

Decisions API รองรับคำถามประเภทใดบ้าง?

Decisions API รองรับคำถามสามประเภท ได้แก่ noul สำหรับการตรวจแบบใช่/ไม่ใช่ choice สำหรับเลือกหนึ่งตัวจาก 2 ถึง 255 และ score สำหรับการให้คะแนนบนเกณฑ์แบบจัดลำดับ สามารถผสมทั้งสามแบบในคำขอเดียวได้

หัวข้อ