Hoppa till huvudinnehållet

Gemini Decisions API: Test av Googles nya beslutsmodell för latens och kostnad

Lär dig hur Gemini Decision 1 poängsätter fasta alternativ utan att generera text, bygg en bank-intentklassificerare med Decisions API och jämför den med Gemini 3.5 Flash-Lite på noggrannhet, latens, kalibrering och kostnad.
· 15 min läs

Utforska med AI

De flesta LLM-appar är fulla av små beslut: Vilket verktyg ska agenten anropa? Vilken modell ska hantera den här frågan? Bryter det här meddelandet mot en policy?

I dag besvarar många team de här frågorna genom att låta en generativ modell skriva svaret som text, för att sedan parsa texten och fatta ett beslut.

Googles Gemini Decisions API tar en annan väg. Det använder modellen Gemini Decision 1 för att poängsätta en fast uppsättning alternativ i ett enda framåtpass och returnerar en sannolikhet för varje alternativ, med noll debiterade utgående token.

I den här guiden kör vi samma uppgift för intentklassificering i två upplägg:

  • Gemini Decision 1 via Decisions API
  • Gemini 3.5 Flash-Lite via Interactions API, med strukturerad JSON-utdata

Vi jämför dem på noggrannhet, latens, tokenanvändning, kostnad och kalibrering, och pressar sedan båda från 1 till 100 frågor i en enda begäran.

I slutet av den här handledningen kommer du att kunna:

  • Anropa Decisions API med choice-frågor och läsa dess sannolikheter och förtroendepoäng

  • Bygga en generativ baslinje med Interactions API och ett JSON-schema

  • Mäta latens, tokenanvändning och kostnad för båda angreppssätten

  • Kontrollera om en modells förtroende går att lita på, med ett reliability-diagram och expected calibration error (ECE)

  • Avgöra när en beslutsmodell passar din app bättre än en generativ

Du kan köra hela koden i denna Google Colab.

Beslutsmodeller vs. generativa modeller

Innan vi ser hur de fungerar definierar vi begreppen.

  • Generativ modell: Den här modellen producerar nytt innehåll. Du ger den en prompt och den skriver ett svar en token i taget. Svaret kan vara allt från ett svar, en sammanfattning och kod till en etikett. Gemini 3.5 Flash-Lite, liksom de flesta LLM:er vi använder i chattappar, är en generativ modell.
  • Beslutsmodell: En beslutsmodell väljer från alternativen du definierar. Du ger den ett input och en fast lista med möjliga svar, och den berättar sannolikheten för varje alternativ utan att skriva en enda textrad. Gemini Decision 1 är en beslutsmodell.

Här är ett exempel. 

En kund skriver till en bank: "Mitt kort har inte kommit än. När kommer det?"

Om du frågar en generativ modell, "Vad vill den här kunden?", kan den svara:

”Kunden väntar på ett nytt kort och vill veta när det kommer.”

Det är ett bra svar för en människa att läsa. Men om din app behöver skicka meddelandet till rätt team måste din kod nu omvandla den meningen till en etikett. Du kan tvinga fram en etikett med ett JSON-schema, men modellen skriver den fortfarande token för token.

Om du däremot frågar en beslutsmodell samma sak ger du först alternativen, som card_arrival, lost_or_stolen_card och exchange_rate. Den returnerar en sannolikhet för varje:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Din kod kan sedan agera direkt på den sannolikheten genom att routa till kortteamet om card_arrival ligger över en tröskel, och skicka till en människa annars. Kort sagt:

 

Generativ modell

Beslutsmodell

Returnerar

Text den skriver

En sannolikhet för varje alternativ du definierar

Möjliga svar

Öppna

Fast uppsättning

Bra för

Svar, sammanfattningar, förklaringar och extrahering

Routing, verktygsval, policyskontroller och betygsättning

I praktiken använder många appar en generativ modell för båda jobben. Det är vad vi testar i nästa avsnitt: om en beslutsmodell gör klassificeringsdelen bättre än en generativ modell.

När du använder en generativ modell som klassificerare skriver den svaret en token i taget. För ett JSON-svar som vårt ser utdata ut så här medan det genereras:

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

Varje token är ett separat avkodningssteg, och varje utgående token debiteras. Om du vill ha en förtroendepoäng måste modellen också skriva det talet. Det talet är modellens egen gissning om sig själv, inte en sannolikhet mätt från dess interna beräkningar.

En beslutsmodell hoppar däremot över skrivsteget. Du ger den alternativen i förväg, och den poängsätter alla mot input i ett enda framåtpass. Resultatet är en sannolikhet för varje alternativ:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Det här ändrar tre saker du kan mäta:

  • Latens: Det finns ingen avkodningsloop, så latensen bör inte växa med svarslängden.
  • Kostnad: Det finns inga utgående token att debitera. Du betalar bara för inkommande token, som inkluderar din frågetext och alternativbeskrivningar.
  • Förtroende: Förtroendet kommer från sannolikheterna själva, så det bör följa hur ofta modellen har rätt.

Avvägningen är att du bara kan ställa frågor med sluten uppsättning. En beslutsmodell kan inte förklara sitt svar, extrahera ett värde eller skriva fri text.

Demo: Bygga en intetklassificerare för bankärenden

I den här demon bygger vi en klassificerare för bank-intenter. Vi använder test-splittet av Banking77, en publik dataset med kundmeddelanden märkta med 77 intent, och behåller 12 intent som är lätta att förväxla med varandra:

  • card_arrival och card_delivery_estimate

  • pending_card_payment, declined_card_payment och card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient och balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate och top_up_failed

Liknande intent gör uppgiften svårare, vilket gör förtroendepoängen mer intressanta att studera.

Vi kör klassificeraren med båda modellerna på två sätt:

  • Ett meddelande per begäran: 180 meddelanden (15 per intent), skickade till varje modell ett i taget.
  • Många frågor per begäran: N meddelanden i ett delat input, med en fråga per meddelande, för N = 1, 5, 10, 25, 50 och 100.

Här är inställningarna vi håller lika för båda modellernas:

Inställning

Värde

Varför 

Beslutsmodell

gemini-decision-1

Modellen vi testar

Generativ modell

gemini-3.5-flash-lite

Den kostnadseffektiva generativa baslinjen som används i lanseringsjämförelsen

Flash-Lite-temperatur

0.0

Tar bort samplingbrus från baslinjen

Flash-Lite thinking level

minimal

Håller jämförelsen till avkodning, inte resonemang

Utdataformat

JSON-schema med ett enum av de 12 etiketterna

Flash-Lite kan bara returnera en giltig etikett

Alternativbeskrivningar

En kort mening per intent

Båda modellerna ser samma etikettsdefinitioner

Uppvärmningssamtal

2 per modell

Håller uppkopplingskostnaden utanför mätningarna

Upprepningar (många frågor per begäran)

3 per inställning

Vi rapporterar medianen, inte en enskild körning

Obs: Detta är arbetsinställningar för den här demon, inte tunade inställningar för någon av modellerna.

Steg 1: Förutsättningar och setup

För att följa med behöver du:

  • En Gemini API-nyckel från Google AI Studio

  • Ett Colab-anteckningsblock (eller valfri Python 3-miljö)

  • google-genai version 3.2 eller senare

Decisions API har en kostnadsfri nivå i Google AI Studio för prototyputveckling, så du kan prova innan du betalar. Jag körde den här demon i Colab, men känn dig fri att använda valfri Python 3-miljö. 

Låt oss börja med att installera paketen:

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

Här är google-genai Googles Python-SDK för Gemini API. Det ger oss metoderna client.decisions.create och client.interactions.create, som skickar begäranden till Decisions API respektive Interactions API. Vi använder pandas för att läsa in datasetet och organisera resultat, och matplotlib för att rita figurer.

Sedan skapar vi klienten. Decisions API kräver API-versionen 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"

Här läser genai.Client() API-nyckeln från GEMINI_API_KEY satt under secrets i Colab eller som en miljövariabel, och http_options pekar den mot v1beta-API:t, där Decisions API finns. 

Sedan läser vi in Banking77-datasetet och definierar våra 12 intent. Varje intent får en mening som beskrivning som båda modellerna ser:

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

Kodsnutten ovan laddar ned Banking77s test-split som en CSV-fil och behåller bara rader märkta med någon av våra 12 intent. Den samplar sedan 15 meddelanden per intent med ett fast slumpfrö, så att du får samma sample vid varje körning. Den sista .sample(frac=1) blandar raderna så att intenten blandas.

Detta ger oss 180 meddelanden, 15 per intent.

Steg 2: Klassificera med Decisions API

En choice-fråga tar en dictionary som mappar varje alternativ-ID till en beskrivning. Vi skickar meddelandet som input och ställer en fråga med nyckeln 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,
    }

Funktionen decide_intent() skickar ett meddelande som input och en choice-fråga med våra 12 intent som alternativ. Vi mäter tiden med time.perf_counter(), och läser sedan toppval, förtroende, alla alternativs sannolikheter och tokenantal från svaret.

Varje svar har tre fält:

  • choice: Alternativet med högst sannolikhet

  • probabilities: En sannolikhet per alternativ, som summerar till 1

  • confidence: Den uppskattade sannolikheten att toppsvaret är korrekt

Objektet usage rapporterar inkommande token, och total_output_tokens är alltid 0.

Här är resultatet för det första meddelandet i vårt sample:

Modellen förväxlade två liknande intent, men dess förtroende på 0,846 visar viss osäkerhet. Den bra delen är att det korrekta intentet, card_arrival, kom tvåa med nästan all återstående sannolikhet (cirka 0,15). Alla andra alternativ låg nära noll.

Steg 3: Klassificera med Flash-Lite

För den generativa baslinjen använder vi strukturerad utdata med ett enum av samma 12 etiketter, så att Flash-Lite bara kan returnera en giltig etikett. Vi ber också om ett förtroende mellan 0 och 1, vilket är hur de flesta appar får en förtroendepoäng från en generativ modell:

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

Funktionen generate_intent() bygger en prompt med de 12 intenten och deras beskrivningar. Den anropar Flash-Lite med response_format satt till vårt JSON-schema, så utdata måste vara giltig JSON med en av de 12 etiketterna. Temperaturen är satt till 0 med minimal thinking level för att hålla svaret stabilt och kort. Vi parsar sedan interaction.output_text med json.loads() och läser tokenantal från interaction.usage.

Jag testade samma meddelande som i föregående steg med Flash-Lite, och den gjorde samma misstag med högre förtroende:

Thinking-tokens är 0, vilket bekräftar att minimal thinking höll Flash-Lite till att bara skriva svaret. Flash-Lite använde färre inkommande token än Decision 1 (277 vs 337) eftersom Decisions API räknar alternativbeskrivningarna inuti frågan som input.

Steg 4: Klassificera ett meddelande per begäran

Nu skickar vi alla 180 meddelanden till båda modellerna, en begäran i taget, efter två uppvärmningssamtal var:

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

Den här loopen skickar varje meddelande till båda funktionerna och sparar prediktion, förtroende, latens och tokenantal som en rad. Vi gör sedan om raderna till en DataFrame och lägger till en kolumn correct som markerar om varje prediktion matchar den sanna etiketten.

Här är resultaten:

Metric

Gemini Decision 1

Gemini 3.5 Flash-Lite

Noggrannhet

84,4%

83,9%

Medianlatens

325 ms

1 068 ms

p90-latens

412 ms

6 483 ms

Långsammaste begäran

1,0 s

101,6 s

Begäranden över 5 s

0 av 180

33 av 180

Medel inkommande token

339

279

Medel utgående token

0

25

Här är tre saker vi lärde oss av dessa mått:

  • Noggrannhet: Båda modellerna var ungefär lika träffsäkra.
  • Latens: Decision 1 var cirka 3x snabbare vid medianen och mycket mer konsekvent, medan Flash-Lite hade en lång svans av långsamma begäranden.
  • Token: Decision 1 använde fler inkommande token eftersom alternativbeskrivningar räknas som input, men den genererade inga utgående token.

Obs: Vår tidsmätning inkluderar nätverksresan från Colab, så behandla det gapet som uppkopplingsberoende.

Steg 5: Kontrollera kalibrering

Noggrannhet berättar hur ofta en modell har rätt, men kalibrering berättar om dess förtroende betyder något eller inte. En modell är välkalibrerad när dess förtroende matchar dess noggrannhet, dvs. om den säger 0,8 på en grupp svar bör cirka 80% av dem vara korrekta.

För att mäta detta grupperar vi prediktioner i 10 förtroendeintervall och jämför varje intervalls genomsnittliga förtroende med dess noggrannhet. Expected calibration error (ECE) är medelgapet, viktat efter hur många prediktioner som hamnar i varje intervall. Lägre är bättre.

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

Funktionen ece() placerar varje prediktion i ett av 10 intervall efter förtroende (0 till 0,1, 0,1 till 0,2 osv.). För varje intervall tar den gapet mellan genomsnittligt förtroende och noggrannhet, viktar det efter andelen prediktioner i intervallet och summerar resultaten.

Så här står sig de två modellerna:

Metric

Gemini Decision 1

Gemini 3.5 Flash-Lite

Noggrannhet

84,4%

83,9%

Medelförtroende

0,867

0,957

ECE

0,050

0,124

Medelförtroende när rätt

0,901

0,966

Medelförtroende när fel

0,686

0,912

Figur: Reliability-diagram för båda modellerna

Decision 1:s förtroende ligger nära dess noggrannhet, med en ECE på 0,050. Det är också tydligt lägre när modellen har fel (0,686) än när den har rätt (0,901).

Flash-Lite är överkonfident. Den rapporterar 0,957 i snitt samtidigt som den har rätt 83,9% av gångerna. Den använde bara 9 distinkta förtroendevärden över 180 svar, och 158 av dem var 0,95 eller högre. Även dess felaktiga svar låg i snitt på 0,912. Siffran ser ut som en sannolikhet, men är modellens egen uppskattning skriven som text.

Kalibrering spelar roll när du agerar på poängen. Ett vanligt mönster är att acceptera svar över en förtroendetröskel och skicka resten till en fallback-modell eller en människa:

Tröskel

Decision 1: andel behållna

Decision 1: noggrannhet på behållna

Flash-Lite: andel behållna

Flash-Lite: noggrannhet på behållna

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%

Med Decision 1 fungerar en högre tröskel som väntat. Vid 0,9 behåller den 63% av meddelandena med 95,6% noggrannhet. Med Flash-Lite hjälper tröskeln knappt, eftersom de flesta felaktiga svar också har högt förtroende. De officiella dokumenten rekommenderar att välja tröskel från märkta exempel på din egen trafik.

Steg 6: Klassificera 100 meddelanden i en begäran

Decisions API kan besvara upp till 1 000 frågor om ett delat input i en enda begäran. För att testa detta lägger vi N kundmeddelanden i ett input och ställer en fråga per meddelande.

För Decision 1 innebär det N choice-frågor med nycklar m1 till 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

Här numrerar funktionen build_batch() de första N meddelandena och fogar ihop dem till ett delat input. Sedan skapar decide_batch() en choice-fråga per meddelande, med nycklar m1 till mN, skickar dem alla i en begäran och läser tillbaka ett svar per nyckel.

För Flash-Lite skickar vi samma delade input med ett JSON-schema som har N fält, vart och ett begränsat till 12 etiketter. Varje N använder samma meddelanden för båda modellerna, och varje inställning körs tre gånger.

Frågor per begäran

Decision 1: medianlatens

Flash-Lite: medianlatens

Decision 1: inkommande token

Flash-Lite: inkommande / utgående token

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

Misslyckades

15 100

Misslyckades

100

59 095 ms

Misslyckades

30 309

Misslyckades

Upp till 25 frågor höll sig Decision 1:s medianlatens under 550 ms. Flash-Lites median växte med N, från under 1 s vid 1 till 5 frågor till 2,75 s vid 25, eftersom den måste skriva varje svar som utgående token. Även vid 50 frågor var Decision 1:s median 592 ms, men en av de tre körningarna tog 70 s.

Här är två viktiga punkter att fundera på:

  • Flash-Lite misslyckades vid 50 och 100 frågor: Raderna ”Misslyckades” i tabellen ovan är alla samma 400-fel. Det visar att schemat ”har för många tillstånd för serving”. Ett schema med 50 eller fler fält, vart och ett begränsat till 12 etiketter, är mer än vad API:t accepterar.
  • Decision 1 blev långsammare vid 100 frågor: Varje fråga upprepar alla 12 alternativbeskrivningar, cirka 300 token per fråga, så begäran nådde 30 309 token, medan Googles påstående om platt latens gäller kontexter upp till 16K token.

Steg 7: Trimma begärandena

Nu uppstår en självklar fråga: kan vi fixa avmattningen och felen? För Decision 1 använder vi tomma alternativbeskrivningar (""). För Flash-Lite ber vi om en lista med N etiketter i stället för N separata fält:

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

Så här gick det för Decision 1 med tomma beskrivningar:

Frågor per begäran

Medianlatens

Noggrannhet

Inkommande token

25

357 ms

84,0%

3 995

50

649 ms

78,0%

7 950

100

1 603 ms

83,0%

16 009

Att ta bort beskrivningarna halverade ungefär antalet inkommande token. Vid 100 frågor kom begäran ner till cirka 16K token, och medianlatensen föll från 59 s till 1,6 s. Noggrannheten sjönk något vid 25 och 50 frågor, så korta beskrivningar är en bättre medelväg än inga, särskilt för liknande intent.

Listsheemat hjälpte inte Flash-Lite-modellen. Det fungerade vid 25 frågor, men misslyckades fortfarande vid 50 och 100.

Steg 8: Jämför kostnad

Till sist beräknar vi kostnaden från tokenantalen som varje API returnerar, med priser för betald nivå:

Modell

Pris för inkommande per 1M token

Pris för utgående per 1M token

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (inklusive thinking-tokens)

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

Funktionen cost_per_request() multiplicerar varje tokenantal med priset per 1M token. För Decision 1 räknas bara inkommande token. För Flash-Lite debiteras thinking-tokens till utgångspris, så vi lägger till dem till utgående token.

Här är kostnaden per 1 000 begäranden för varje upplägg:

Upplägg

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1 meddelande per begäran

$0,034

$0,147

4,3x

5 frågor per begäran

$0,155

$0,271

1,7x

10 frågor per begäran

$0,306

$0,459

1,5x

25 frågor per begäran

$0,757

$1,088

1,4x

25 frågor, trimmade upplägg (Steg 7)

$0,400

$0,831

2,1x

50 frågor per begäran

$1,510

Misslyckades

n/a

100 frågor, tomma beskrivningar

$1,601

Misslyckades

n/a

För enstaka meddelanden var Decision 1 4,3x billigare, men gapet krymper när du batchar fler frågor i en begäran. Det delade inputet debiteras en gång i båda API:erna. Men varje Decision 1-fråga bär med sig sin instruktion och alla 12 alternativbeskrivningar, medan Flash-Lite ser etikettlistan bara en gång och betalar för en kort utdata per svar. Vid 25 frågor använde Decision 1 7 570 inkommande token mot Flash-Lites 710 inkommande och 350 utgående token.

Obs: Decisions API stöder inte kontext-cache eller Batch API. Om du skickar samma input i flera begäranden debiteras det fullt ut varje gång. Så när du har många frågor om samma input, ställ dem i en begäran i stället för att sprida ut dem.

När du ska använda respektive angreppssätt

Baserat på körningarna ovan passar en beslutsmodell bättre när:

  • Svaret kommer från en fast uppsättning alternativ, som intent, rutter, verktyg eller policyetiketter
  • Beslutet ligger i anropsvägen, där varje användare väntar på det
  • Du vill agera på förtroendet, till exempel genom att skicka oklara fall till en fallback eller en människa
  • Du behöver ställa många oberoende frågor om samma input i en begäran

En generativ modell passar fortfarande bättre när:

  • Du behöver en förklaring, ett extraherat värde eller fri text
  • Uppsättningen av möjliga svar är öppen eller ändras per begäran
  • Du redan gjort ett generativt anrop på det inputet och kan lägga till klassificeringen där

Använd Decisions API när du behöver

Använd Interactions API när du behöver

En ja/nej-sannolikhet, ett alternativ från en fast uppsättning eller ett betyg på en fast skala

Genererad text, sammanfattningar eller förklaringar

Kalibrerade sannolikheter som du kan tröska

Extraherade värden eller objekt som följer ditt eget JSON-schema

Många oberoende kontroller över samma input i ett anrop

Verktygsanrop med argument

Låg latens och noll kostnad för utgående token

Flerstegsresonemang

Avslutande tankar

I den här handledningen byggde vi en klassificerare för bank-intenter med Gemini Decision 1 och Gemini 3.5 Flash-Lite, och beräknade sedan noggrannhet, latens, kalibrering och kostnad för att jämföra modellerna. Här är fyra slutsatser:

  • Noggrannhet slutade oavgjort: 84,4% för Decision 1 och 83,9% för Flash-Lite, med samma utslag på 163 av 180 meddelanden.
  • Decision 1 var snabbare och mer förutsägbar: Dess medianlatens var 325 ms mot 1 068 ms, och dess långsammaste begäran tog 1,0 s mot 101,6 s.
  • Decision 1:s förtroende var användbart: Dess ECE var 0,050 mot 0,124, och att höja tröskeln till 0,9 höjde noggrannheten på behållna svar från 84,4% till 95,6%. Flash-Lites självrapporterade förtroende skilde knappt rätt från fel.
  • Kostnad och skala beror på hur du skriver frågorna: Decision 1 var 4,3x billigare för enstaka meddelanden, men varje fråga betalar för sina alternativbeskrivningar. Håll därför den totala inputen under cirka 16K token och håll alternativbeskrivningarna korta.

Dessa resultat kommer från en uppgift, ett dataset och ett litet antal körningar från ett Colab-anteckningsblock. Du kan se dem som observationer från en demo snarare än allmänna prestandapåståenden. 

FAQs

Vad är skillnaden mellan Decisions API och ett generativt API?

Ett generativt API skriver sitt svar token för token och debiterar varje utgående token. Decisions API poängsätter en fast uppsättning alternativ i ett framåtpass och returnerar en sannolikhet för vart och ett. Det genererar inga utgående token, så du betalar bara för input.

Är Gemini Decision 1 mer träffsäker än Gemini 3.5 Flash-Lite?

Inte i vårt test. På 180 bankmeddelanden var noggrannheten 84,4% för Decision 1 och 83,9% för Flash-Lite. Skillnaderna vi mätte låg i latens, kalibrering och kostnad.

Varför använder Decision 1 fler inkommande token än Flash-Lite?

Varje frågas instruktion och alternativbeskrivningar räknas som input. Med 12 beskrivna alternativ lade det till cirka 300 token per fråga i vårt test. Korta eller tomma alternativbeskrivningar minskar detta.

Förblir latensen platt när jag lägger till fler frågor?

Inte i våra körningar. Medianen låg under 650 ms upp till 50 frågor. Vid 100 frågor med fullständiga alternativbeskrivningar nådde begäran cirka 30K token och tog 48 till 59 s. Med tomma beskrivningar fick samma 100 frågor plats i cirka 16K token och tog 1,6 s.

Vilka frågetyper stöder Decisions API?

Decisions API stöder tre frågetyper, inklusive noul för ja/nej-kontroller, choice för att välja ett alternativ från 2 till 255, och score för betygsättning på en ordnad rubric. Du kan blanda alla tre i en begäran.

Ämnen