Chuyển đến nội dung chính

Gemini Decisions API: Kiểm thử Mô hình Quyết định mới của Google về Độ trễ và Chi phí

Tìm hiểu cách Gemini Decision 1 chấm điểm các lựa chọn cố định mà không sinh văn bản, xây dựng bộ phân loại ý định ngân hàng với Decisions API, và so sánh với Gemini 3.5 Flash-Lite về độ chính xác, độ trễ, hiệu chuẩn và chi phí.
· 15 phút đọc

Khám phá cùng AI

Hầu hết các ứng dụng LLM đều chứa đầy những quyết định nhỏ: Tác tử nên gọi công cụ nào? Mô hình nào nên xử lý truy vấn này? Thông điệp này có vi phạm chính sách không?

Hiện nay, nhiều nhóm trả lời những câu hỏi này bằng cách yêu cầu một mô hình sinh tạo viết câu trả lời dưới dạng văn bản, rồi phân tích văn bản đó để ra quyết định.

Gemini Decisions API của Google áp dụng một cách tiếp cận khác. API này sử dụng mô hình Gemini Decision 1 để chấm điểm một tập lựa chọn cố định trong một lần suy luận và trả về xác suất cho mỗi lựa chọn, với số token đầu ra được tính phí bằng 0.

Trong hướng dẫn này, chúng ta sẽ chạy cùng một tác vụ phân loại ý định trên hai thiết lập:

  • Gemini Decision 1 qua Decisions API
  • Gemini 3.5 Flash-Lite qua Interactions API, sử dụng đầu ra JSON có cấu trúc

Chúng ta sẽ so sánh chúng về độ chính xác, độ trễ, mức sử dụng token, chi phí và hiệu chuẩn, sau đó đẩy cả hai từ 1 lên 100 câu hỏi trong một yêu cầu.

Kết thúc hướng dẫn này, bạn sẽ biết cách:

  • Gọi Decisions API với câu hỏi choice và đọc xác suất cùng điểm tin cậy của nó

  • Xây dựng baseline sinh tạo với Interactions API và một JSON schema

  • Đo độ trễ, mức sử dụng token và chi phí cho cả hai cách tiếp cận

  • Kiểm tra độ tin cậy của điểm tin cậy mô hình bằng biểu đồ reliability và sai số hiệu chuẩn kỳ vọng (ECE)

  • Quyết định khi nào mô hình quyết định phù hợp với ứng dụng của bạn hơn mô hình sinh tạo

Bạn có thể chạy toàn bộ mã trong Google Colab.

Mô hình Quyết định so với Mô hình Sinh tạo

Trước khi xem cách hoạt động của từng mô hình, hãy thống nhất hai khái niệm này.

  • Mô hình sinh tạo: Mô hình này tạo ra nội dung mới. Bạn cung cấp một prompt và nó viết phản hồi từng token một. Phản hồi có thể là câu trả lời, tóm tắt, mã, hoặc nhãn. Gemini 3.5 Flash-Lite, như đa số LLM dùng trong ứng dụng chat, là một mô hình sinh tạo.
  • Mô hình quyết định: Một mô hình quyết định chọn từ các phương án bạn xác định. Bạn đưa vào đầu vào và danh sách câu trả lời cố định, và nó trả về xác suất của từng phương án mà không viết một dòng văn bản nào. Gemini Decision 1 là một mô hình quyết định.

Dưới đây là một ví dụ. 

Một khách hàng viết cho ngân hàng: "Thẻ của tôi vẫn chưa đến. Khi nào sẽ nhận được?"

Nếu bạn hỏi một mô hình sinh tạo, "Khách hàng này muốn gì?", nó có thể trả lời:

“Khách hàng đang chờ thẻ mới và muốn biết khi nào thẻ sẽ đến.”

Đó là câu trả lời tốt cho con người đọc. Nhưng nếu ứng dụng của bạn cần định tuyến thông điệp đến đúng nhóm, mã của bạn giờ phải chuyển câu đó thành nhãn. Bạn có thể ép ra nhãn bằng JSON schema, nhưng mô hình vẫn phải viết từng token một.

Tuy nhiên, nếu bạn hỏi một mô hình quyết định điều tương tự, trước hết bạn cung cấp các lựa chọn như card_arrival, lost_or_stolen_card, và exchange_rate. Nó trả về xác suất cho từng lựa chọn:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Mã của bạn sau đó có thể hành động trực tiếp dựa trên xác suất đó bằng cách định tuyến đến nhóm thẻ nếu card_arrival vượt một ngưỡng, và chuyển cho con người nếu không. Tóm lại:

 

Mô hình sinh tạo

Mô hình quyết định

Trả về

Văn bản nó viết

Xác suất cho từng lựa chọn bạn định nghĩa

Câu trả lời có thể

Mở

Tập cố định

Phù hợp cho

Câu trả lời, tóm tắt, giải thích và trích xuất

Định tuyến, chọn công cụ, kiểm tra chính sách và chấm điểm

Trong thực tế, nhiều ứng dụng dùng một mô hình sinh tạo cho cả hai việc. Đó là điều chúng ta sẽ kiểm thử ở phần tiếp theo: liệu một mô hình quyết định có làm tốt phần phân loại hơn một mô hình sinh tạo không.

Khi bạn dùng mô hình sinh tạo làm bộ phân loại, nó viết câu trả lời từng token một. Với câu trả lời JSON như của chúng ta, đầu ra trông như thế này trong quá trình sinh:

{
{"intent":
{"intent": "card_arrival",
{"intent": "card_arrival", "confidence": 0.95}

Mỗi token là một bước giải mã riêng, và mỗi token đầu ra đều bị tính phí. Nếu bạn muốn điểm tin cậy, mô hình cũng phải viết con số đó. Con số đó là dự đoán của chính mô hình về bản thân nó, không phải một xác suất đo từ nội bộ mô hình.

Trong khi đó, mô hình quyết định bỏ qua bước viết này. Bạn đưa các lựa chọn ngay từ đầu, và nó chấm tất cả so với đầu vào trong một lần suy luận. Kết quả là một xác suất cho mọi lựa chọn:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Điều này thay đổi ba yếu tố bạn có thể đo lường:

  • Độ trễ: Không có vòng lặp giải mã, nên độ trễ không nên tăng theo độ dài câu trả lời.
  • Chi phí: Không có token đầu ra để tính phí. Bạn chỉ trả cho token đầu vào, gồm văn bản câu hỏi và mô tả các lựa chọn.
  • Độ tin cậy: Điểm tin cậy đến từ các xác suất, nên nó sẽ phản ánh tần suất mô hình đúng.

Đánh đổi là bạn chỉ có thể hỏi câu hỏi có tập đáp án đóng. Mô hình quyết định không thể giải thích câu trả lời, trích xuất giá trị, hay viết văn bản tự do.

Demo: Xây dựng bộ phân loại ý định ngân hàng

Trong demo này, chúng ta sẽ xây dựng bộ phân loại ý định ngân hàng. Chúng ta sẽ dùng tập kiểm tra của Banking77, một bộ dữ liệu công khai gồm các thông điệp khách hàng được gán nhãn với 77 ý định, và giữ lại 12 ý định dễ gây nhầm lẫn với nhau:

  • card_arrival và card_delivery_estimate

  • pending_card_payment, declined_card_payment, và card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient, và balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate, và top_up_failed

Các ý định tương tự khiến tác vụ khó hơn, từ đó điểm tin cậy đáng để nghiên cứu hơn.

Chúng ta sẽ chạy bộ phân loại với cả hai mô hình theo hai cách:

  • Một thông điệp mỗi yêu cầu: 180 thông điệp (15 mỗi ý định), gửi đến từng mô hình lần lượt.
  • Nhiều câu hỏi mỗi yêu cầu: N thông điệp đặt trong một đầu vào dùng chung, với một câu hỏi cho mỗi thông điệp, với N = 1, 5, 10, 25, 50 và 100.

Dưới đây là các thiết lập chúng ta giữ nguyên cho cả hai mô hìnhs:

Thiết lập

Giá trị dùng

Lý do 

Mô hình quyết định

gemini-decision-1

Mô hình cần kiểm thử

Mô hình sinh tạo

gemini-3.5-flash-lite

Baseline sinh tạo tiết kiệm chi phí được dùng trong bài ra mắt để so sánh

Nhiệt độ Flash-Lite

0.0

Loại bỏ nhiễu do lấy mẫu khỏi baseline

Mức độ suy nghĩ của Flash-Lite

minimal

Giữ so sánh tập trung vào giải mã, không phải suy luận

Định dạng đầu ra

JSON schema với enum gồm 12 nhãn

Flash-Lite chỉ có thể trả về một nhãn hợp lệ

Mô tả lựa chọn

Một câu ngắn cho mỗi ý định

Cả hai mô hình cùng thấy định nghĩa nhãn như nhau

Lệnh gọi khởi động

2 mỗi mô hình

Loại trừ thời gian thiết lập kết nối khỏi phép đo

Số lần lặp (nhiều câu hỏi mỗi yêu cầu)

3 cho mỗi thiết lập

Báo cáo trung vị, không dùng một lần chạy duy nhất

Lưu ý: Đây là các thiết lập làm việc cho demo này, không phải thiết lập đã tinh chỉnh cho bất kỳ mô hình nào.

Bước 1: Điều kiện tiên quyết và thiết lập

Để theo dõi, bạn cần:

  • Một khóa API Gemini từ Google AI Studio

  • Một sổ tay Colab (hoặc bất kỳ môi trường Python 3 nào)

  • google-genai phiên bản 3.2 hoặc mới hơn

Decisions API có bậc miễn phí trong Google AI Studio để dựng thử, nên bạn có thể dùng thử trước khi trả phí. Tôi đã chạy demo này trong Colab, nhưng bạn có thể dùng bất kỳ môi trường Python 3 nào. 

Hãy bắt đầu bằng cách cài đặt các gói:

!pip install -q -U "google-genai>=3.2" pandas matplotlib

Ở đây, google-genai là SDK Python của Google cho Gemini API. Nó cung cấp cho chúng ta các phương thức client.decisions.create và client.interactions.create, dùng để gửi yêu cầu đến Decisions API và Interactions API. Chúng ta dùng pandas để tải bộ dữ liệu và tổ chức kết quả, và matplotlib để vẽ hình.

Tiếp theo, chúng ta tạo client. Decisions API cần phiên bản API v1beta:

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"

Ở đây, genai.Client() đọc khóa API từ GEMINI_API_KEY được đặt trong mục bí mật của Colab hoặc như biến môi trường, và http_options trỏ đến API v1beta, nơi Decisions API hoạt động. 

Sau đó, chúng ta tải bộ dữ liệu Banking77 và định nghĩa 12 ý định. Mỗi ý định có một mô tả một câu mà cả hai mô hình sẽ thấy:

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)
)

Đoạn mã trên tải tập kiểm tra Banking77 dưới dạng tệp CSV và chỉ giữ các hàng có nhãn là một trong 12 ý định của chúng ta. Sau đó lấy mẫu 15 thông điệp mỗi ý định với hạt giống ngẫu nhiên cố định, để bạn nhận cùng một mẫu ở mỗi lần chạy. Lệnh .sample(frac=1) cuối cùng xáo trộn các hàng để trộn lẫn các ý định.

Điều này cho chúng ta 180 thông điệp, 15 cho mỗi ý định.

Bước 2: Phân loại với Decisions API

Một câu hỏi choice nhận một từ điển ánh xạ mỗi ID lựa chọn với một mô tả. Chúng ta truyền thông điệp làm input và hỏi một câu hỏi, khóa là 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,
    }

Hàm decide_intent() gửi một thông điệp làm input và một câu hỏi choice với 12 ý định là các lựa chọn. Chúng ta đo thời gian gọi bằng time.perf_counter(), rồi đọc lựa chọn cao nhất, điểm tin cậy, tất cả xác suất của lựa chọn, và số token từ phản hồi.

Mỗi câu trả lời có ba trường:

  • choice: Lựa chọn có xác suất cao nhất

  • probabilities: Một xác suất cho mỗi lựa chọn, tổng bằng 1

  • confidence: Xác suất ước tính rằng câu trả lời cao nhất là đúng

Đối tượng usage báo cáo token đầu vào, và total_output_tokens luôn là 0.

Đây là kết quả cho thông điệp đầu tiên trong mẫu của chúng ta:

Mô hình nhầm lẫn giữa hai ý định tương tự, nhưng điểm tin cậy 0.846 cho thấy có sự không chắc chắn. Điểm tích cực là ý định đúng, card_arrival, đứng thứ hai với gần như toàn bộ xác suất còn lại (khoảng 0.15). Tất cả lựa chọn khác gần như bằng 0.

Bước 3: Phân loại với Flash-Lite

Với baseline sinh tạo, chúng ta dùng đầu ra có cấu trúc với enum gồm cùng 12 nhãn, để Flash-Lite chỉ có thể trả về nhãn hợp lệ. Chúng ta cũng yêu cầu một điểm tin cậy từ 0 đến 1, đây là cách phần lớn ứng dụng lấy điểm tin cậy từ mô hình sinh tạo:

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,
    }

Hàm generate_intent() dựng một prompt với 12 ý định và mô tả của chúng. Hàm gọi Flash-Lite với response_format đặt theo JSON schema của chúng ta, để đầu ra buộc phải là JSON hợp lệ với một trong 12 nhãn. Nhiệt độ đặt 0 với mức suy nghĩ minimal để giữ câu trả lời ổn định và ngắn. Sau đó chúng ta phân tích interaction.output_text bằng json.loads() và đọc số token từ interaction.usage.

Tôi đã thử cùng thông điệp như bước trước với Flash-Lite, và mô hình mắc cùng lỗi nhưng với độ tin cậy cao hơn:

Số token suy nghĩ bằng 0, xác nhận rằng mức minimal giữ Flash-Lite chỉ viết câu trả lời. Flash-Lite dùng ít token đầu vào hơn Decision 1 (277 so với 337) vì Decisions API tính cả mô tả lựa chọn bên trong câu hỏi là đầu vào.

Bước 4: Phân loại một thông điệp mỗi yêu cầu

Giờ hãy gửi toàn bộ 180 thông điệp đến cả hai mô hình, mỗi lần một yêu cầu, sau hai lệnh gọi khởi động cho mỗi mô hình:

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"]

Vòng lặp này gửi mỗi thông điệp đến cả hai hàm và lưu dự đoán, điểm tin cậy, độ trễ và số token thành một hàng. Sau đó chúng ta chuyển các hàng thành DataFrame và thêm cột correct đánh dấu dự đoán có khớp nhãn thật hay không.

Dưới đây là kết quả:

Chỉ số

Gemini Decision 1

Gemini 3.5 Flash-Lite

Độ chính xác

84,4%

83,9%

Độ trễ trung vị

325 ms

1.068 ms

Độ trễ p90

412 ms

6.483 ms

Yêu cầu chậm nhất

1,0 s

101,6 s

Yêu cầu trên 5 s

0 trên 180

33 trên 180

Token đầu vào trung bình

339

279

Token đầu ra trung bình

0

25

Có ba điều chúng ta học được từ các chỉ số này:

  • Độ chính xác: Cả hai mô hình đều chính xác tương đương nhau.
  • Độ trễ: Decision 1 nhanh hơn khoảng 3 lần ở trung vị và nhất quán hơn nhiều, trong khi Flash-Lite có đuôi dài các yêu cầu chậm.
  • Token: Decision 1 dùng nhiều token đầu vào hơn vì mô tả lựa chọn được tính là đầu vào, nhưng không sinh token đầu ra.

Lưu ý: Thời gian đo bao gồm chuyến khứ hồi mạng từ Colab, nên coi khoảng này là phụ thuộc vào thiết lập của bạn.

Bước 5: Kiểm tra hiệu chuẩn

Độ chính xác cho biết mô hình đúng thường xuyên thế nào, còn hiệu chuẩn cho biết điểm tin cậy có ý nghĩa hay không. Một mô hình được hiệu chuẩn tốt khi điểm tin cậy khớp với độ chính xác, tức là nếu nó báo 0,8 cho một nhóm câu trả lời, khoảng 80% trong số đó nên đúng.

Để đo điều này, chúng ta nhóm dự đoán vào 10 thùng theo điểm tin cậy và so sánh điểm tin cậy trung bình với độ chính xác của từng thùng. Sai số hiệu chuẩn kỳ vọng (ECE) là khoảng cách trung bình, có trọng số theo số dự đoán rơi vào mỗi thùng. Thấp hơn là tốt hơn.

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

Hàm ece() đặt mỗi dự đoán vào một trong 10 thùng theo điểm tin cậy (0 đến 0,1, 0,1 đến 0,2, v.v.). Với mỗi thùng, nó lấy khoảng cách giữa điểm tin cậy trung bình và độ chính xác, nhân với tỷ trọng dự đoán trong thùng đó, rồi cộng lại.

Dưới đây là so sánh giữa hai mô hình:

Chỉ số

Gemini Decision 1

Gemini 3.5 Flash-Lite

Độ chính xác

84,4%

83,9%

Điểm tin cậy trung bình

0,867

0,957

ECE

0,050

0,124

Điểm tin cậy TB khi đúng

0,901

0,966

Điểm tin cậy TB khi sai

0,686

0,912

Hình: Biểu đồ reliability cho cả hai mô hình

Điểm tin cậy của Decision 1 gần với độ chính xác, với ECE là 0,050. Điểm cũng thấp rõ rệt khi mô hình sai (0,686) so với khi đúng (0,901).

Flash-Lite quá tự tin. Nó báo 0,957 trung bình trong khi đúng 83,9% thời gian. Nó chỉ dùng 9 giá trị tin cậy khác nhau trên 180 câu trả lời, và 158 trong số đó là 0,95 hoặc cao hơn. Ngay cả các câu trả lời sai cũng trung bình 0,912. Con số trông giống xác suất, nhưng đó là ước lượng do mô hình tự viết dưới dạng văn bản.

Hiệu chuẩn quan trọng khi bạn hành động dựa trên điểm. Mẫu hình thường gặp là chấp nhận câu trả lời trên một ngưỡng tin cậy và gửi phần còn lại đến mô hình dự phòng hoặc con người:

Ngưỡng

Decision 1: tỷ lệ giữ lại

Decision 1: độ chính xác trên phần giữ

Flash-Lite: tỷ lệ giữ lại

Flash-Lite: độ chính xác trên phần giữ

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%

Với Decision 1, ngưỡng cao hơn hoạt động như mong đợi. Ở 0,9, nó giữ 63% thông điệp với độ chính xác 95,6%. Với Flash-Lite, ngưỡng hầu như không giúp ích, vì đa số câu trả lời sai cũng có điểm tin cậy cao. Tài liệu chính thức khuyến nghị chọn ngưỡng dựa trên các ví dụ có nhãn từ lưu lượng của chính bạn.

Bước 6: Phân loại 100 thông điệp trong một yêu cầu

Decisions API có thể trả lời tối đa 1.000 câu hỏi về một đầu vào dùng chung trong một yêu cầu. Để kiểm thử điều này, chúng ta đặt N thông điệp khách hàng vào một đầu vào và hỏi một câu hỏi cho mỗi thông điệp.

Với Decision 1, điều đó nghĩa là N câu hỏi choice khóa từ m1 đến 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

Ở đây, hàm build_batch() đánh số N thông điệp đầu tiên và ghép chúng thành một đầu vào dùng chung. Sau đó decide_batch() tạo một câu hỏi choice cho mỗi thông điệp, khóa từ m1 đến mN, gửi tất cả trong một yêu cầu, và đọc về một câu trả lời cho mỗi khóa.

Với Flash-Lite, chúng ta gửi cùng đầu vào dùng chung với một JSON schema có N trường, mỗi trường giới hạn trong 12 nhãn. Mỗi N dùng cùng các thông điệp cho cả hai mô hình, và mỗi thiết lập chạy ba lần.

Câu hỏi mỗi yêu cầu

Decision 1: độ trễ trung vị

Flash-Lite: độ trễ trung vị

Decision 1: token đầu vào

Flash-Lite: token đầu vào / đầu ra

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

Thất bại

15.100

Thất bại

100

59.095 ms

Thất bại

30.309

Thất bại

Tới 25 câu hỏi, độ trễ trung vị của Decision 1 vẫn dưới 550 ms. Độ trễ trung vị của Flash-Lite tăng theo N, từ dưới 1 giây ở 1 đến 5 câu hỏi lên 2,75 giây ở 25, vì nó phải viết từng câu trả lời thành token đầu ra. Ngay cả ở 50 câu hỏi, trung vị của Decision 1 là 592 ms, dù một trong ba lần chạy mất 70 giây.

Có hai điểm then chốt cần cân nhắc:

  • Flash-Lite thất bại ở 50 và 100 câu hỏi: Các hàng "Thất bại" trong bảng trên đều là cùng lỗi 400. Nó cho thấy schema "có quá nhiều trạng thái để phục vụ." Một schema với 50 trường trở lên, mỗi trường giới hạn trong 12 nhãn, vượt quá mức API chấp nhận.
  • Decision 1 chậm lại ở 100 câu hỏi: Mỗi câu hỏi lặp lại toàn bộ 12 mô tả lựa chọn, khoảng 300 token mỗi câu hỏi, nên yêu cầu đạt 30.309 token, trong khi cam kết độ trễ phẳng của Google áp dụng cho ngữ cảnh đến 16K token.

Bước 7: Tinh gọn yêu cầu

Giờ nảy sinh câu hỏi rõ ràng: chúng ta có thể khắc phục sự chậm và lỗi không? Với Decision 1, chúng ta dùng mô tả lựa chọn rỗng (""). Với Flash-Lite, chúng ta yêu cầu một danh sách N nhãn thay vì N trường riêng lẻ:

# 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"],
}

Dưới đây là kết quả của Decision 1 khi bỏ mô tả:

Câu hỏi mỗi yêu cầu

Độ trễ trung vị

Độ chính xác

Token đầu vào

25

357 ms

84,0%

3.995

50

649 ms

78,0%

7.950

100

1.603 ms

83,0%

16.009

Việc bỏ mô tả giúp giảm khoảng một nửa token đầu vào. Ở 100 câu hỏi, yêu cầu giảm xuống khoảng 16K token, và độ trễ trung vị giảm từ 59 giây còn 1,6 giây. Độ chính xác giảm nhẹ ở 25 và 50 câu hỏi, nên mô tả ngắn là điểm trung dung tốt hơn là không có, đặc biệt với các ý định tương tự.

Schema dạng danh sách không giúp được mô hình Flash-Lite. Nó hoạt động ở 25 câu hỏi, nhưng vẫn thất bại ở 50 và 100.

Bước 8: So sánh chi phí

Cuối cùng, chúng ta tính chi phí từ số token mỗi API trả về, sử dụng giá ở bậc trả phí:

Mô hình

Giá đầu vào mỗi 1M token

Giá đầu ra mỗi 1M token

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (bao gồm token suy nghĩ)

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

Hàm cost_per_request() nhân số token với giá mỗi 1M token. Với Decision 1, chỉ tính token đầu vào. Với Flash-Lite, token suy nghĩ bị tính ở giá đầu ra, nên chúng ta cộng vào token đầu ra.

Dưới đây là chi phí cho 1.000 yêu cầu cho mỗi thiết lập:

Thiết lập

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1 thông điệp mỗi yêu cầu

$0,034

$0,147

4,3x

5 câu hỏi mỗi yêu cầu

$0,155

$0,271

1,7x

10 câu hỏi mỗi yêu cầu

$0,306

$0,459

1,5x

25 câu hỏi mỗi yêu cầu

$0,757

$1,088

1,4x

25 câu hỏi, thiết lập tinh gọn (Bước 7)

$0,400

$0,831

2,1x

50 câu hỏi mỗi yêu cầu

$1,510

Thất bại

n/a

100 câu hỏi, mô tả rỗng

$1,601

Thất bại

n/a

Với thông điệp đơn, Decision 1 rẻ hơn 4,3 lần, nhưng khoảng cách thu hẹp khi bạn gom nhiều câu hỏi vào một yêu cầu. Đầu vào dùng chung chỉ bị tính phí một lần ở cả hai API. Nhưng mỗi câu hỏi của Decision 1 mang theo hướng dẫn riêng và toàn bộ 12 mô tả lựa chọn, trong khi Flash-Lite chỉ thấy danh sách nhãn một lần và trả cho đầu ra ngắn mỗi câu trả lời. Ở 25 câu hỏi, Decision 1 dùng 7.570 token đầu vào so với 710 token đầu vào và 350 token đầu ra của Flash-Lite.

Lưu ý: Decisions API không hỗ trợ bộ nhớ đệm ngữ cảnh hay Batch API. Nếu bạn gửi cùng đầu vào trong nhiều yêu cầu, nó sẽ bị tính phí đầy đủ mỗi lần. Vì vậy, khi bạn có nhiều câu hỏi về cùng một đầu vào, hãy hỏi chúng trong một yêu cầu thay vì rải ra nhiều lần gọi.

Khi nào dùng mỗi cách tiếp cận

Dựa trên các lần chạy trên, mô hình quyết định phù hợp hơn khi:

  • Câu trả lời đến từ một tập lựa chọn cố định, như ý định, tuyến, công cụ, hoặc nhãn chính sách
  • Quyết định nằm trên đường đi của yêu cầu, nơi mọi người dùng đều phải chờ
  • Bạn muốn hành động dựa trên điểm tin cậy, ví dụ gửi các trường hợp không rõ ràng đến mô hình dự phòng hoặc con người
  • Bạn cần hỏi nhiều câu hỏi độc lập về cùng một đầu vào trong một yêu cầu

Mô hình sinh tạo vẫn phù hợp hơn khi:

  • Bạn cần giải thích, trích xuất giá trị, hoặc bất kỳ văn bản tự do nào
  • Tập câu trả lời có thể là mở hoặc thay đổi theo từng yêu cầu
  • Bạn đã thực hiện một lệnh gọi sinh tạo trên đầu vào đó và có thể thêm phần phân loại vào cùng lệnh gọi

Dùng Decisions API khi bạn cần

Dùng Interactions API khi bạn cần

Xác suất có/không, một lựa chọn từ một tập cố định, hoặc điểm trên một thang cố định

Văn bản sinh tạo, tóm tắt, hoặc giải thích

Xác suất đã hiệu chuẩn có thể đặt ngưỡng

Giá trị hoặc đối tượng trích xuất tuân theo JSON schema của bạn

Nhiều kiểm tra độc lập trên cùng một đầu vào trong một lần gọi

Gọi công cụ với tham số

Độ trễ thấp và chi phí token đầu ra bằng 0

Suy luận nhiều bước

Tổng kết

Trong hướng dẫn này, chúng ta đã xây dựng một bộ phân loại ý định ngân hàng với Gemini Decision 1 và Gemini 3.5 Flash-Lite, sau đó tính toán độ chính xác, độ trễ, hiệu chuẩn và chi phí để so sánh hai mô hình. Dưới đây là bốn điểm rút ra:

  • Độ chính xác tương đương: 84,4% cho Decision 1 và 83,9% cho Flash-Lite, với cùng phán quyết trên 163/180 thông điệp.
  • Decision 1 nhanh hơn và ổn định hơn: Độ trễ trung vị 325 ms so với 1.068 ms, và yêu cầu chậm nhất là 1,0 giây so với 101,6 giây.
  • Điểm tin cậy của Decision 1 có thể sử dụng: ECE là 0,050 so với 0,124, và nâng ngưỡng lên 0,9 tăng độ chính xác trên phần giữ lại từ 84,4% lên 95,6%. Điểm tin cậy tự báo của Flash-Lite hầu như không tách bạch câu trả lời đúng và sai.
  • Chi phí và khả năng mở rộng phụ thuộc vào cách bạn viết câu hỏi: Decision 1 rẻ hơn 4,3 lần trên thông điệp đơn, nhưng mỗi câu hỏi phải trả cho mô tả lựa chọn. Vì vậy, hãy giữ tổng đầu vào dưới khoảng 16K token và giữ mô tả lựa chọn ngắn.

Các kết quả này đến từ một tác vụ, một bộ dữ liệu, và một số lần chạy nhỏ trong sổ tay Colab. Hãy coi chúng là quan sát từ một demo hơn là tuyên bố hiệu năng tổng quát. 

Aashi Dutt

Tác giả

Aashi Dutt

Tôi là Chuyên gia Google Developers trong lĩnh vực ML (Gen AI), Chuyên gia Kaggle 3x và Đại sứ Women Techmakers với hơn 3 năm kinh nghiệm trong ngành công nghệ. Tôi đồng sáng lập một startup công nghệ y tế vào năm 2020 và hiện đang theo học thạc sĩ khoa học máy tính tại Georgia Tech, chuyên sâu về học máy.

FAQs

Sự khác biệt giữa Decisions API và một API sinh tạo là gì?

Một API sinh tạo viết câu trả lời từng token một và tính phí mỗi token đầu ra. Decisions API chấm điểm một tập lựa chọn cố định trong một lần suy luận và trả về xác suất cho từng lựa chọn. API này không sinh token đầu ra, nên bạn chỉ trả cho đầu vào.

Gemini Decision 1 có chính xác hơn Gemini 3.5 Flash-Lite không?

Không trong thử nghiệm của chúng tôi. Trên 180 thông điệp ngân hàng, độ chính xác là 84,4% cho Decision 1 và 83,9% cho Flash-Lite. Khác biệt chúng tôi đo được là độ trễ, hiệu chuẩn và chi phí.

Tại sao Decision 1 dùng nhiều token đầu vào hơn Flash-Lite?

Hướng dẫn của mỗi câu hỏi và mô tả lựa chọn đều được tính là đầu vào. Với 12 lựa chọn có mô tả, điều đó thêm khoảng 300 token mỗi câu hỏi trong thử nghiệm của chúng tôi. Mô tả ngắn hoặc rỗng sẽ giảm bớt điều này.

Độ trễ có giữ phẳng khi tôi tăng số câu hỏi không?

Trong các lần chạy của chúng tôi, trung vị ở dưới 650 ms tới 50 câu hỏi. Ở 100 câu hỏi với mô tả lựa chọn đầy đủ, yêu cầu đạt khoảng 30K token và mất 48 đến 59 giây. Với mô tả rỗng, cùng 100 câu hỏi vừa khoảng 16K token và mất 1,6 giây.

Decisions API hỗ trợ những loại câu hỏi nào?

Decisions API hỗ trợ ba loại câu hỏi, gồm noul cho kiểm tra có/không, choice để chọn một lựa chọn từ 2 đến 255, và score để chấm trên thang có thứ tự. Bạn có thể trộn cả ba trong một yêu cầu.

Chủ đề

Liên quan