Gemini Decisions API: Google’s nieuwe beslismodel testen op latentie en kosten
Leer hoe Gemini Decision 1 vaste opties scoort zonder tekst te genereren, bouw een intent-classifier voor banken met de Decisions API en vergelijk die met Gemini 3.5 Flash-Lite op nauwkeurigheid, latentie, calibratie en kosten.
De meeste LLM-apps zitten vol met kleine beslissingen: Welke tool moet de agent aanroepen? Welk model moet deze vraag afhandelen? Overtreedt dit bericht een policy?
Vandaag beantwoorden veel teams deze vragen door een generatief model te vragen het antwoord als tekst te schrijven, en die tekst vervolgens te parsen om een beslissing te nemen.
Google's Gemini Decisions API kiest een andere aanpak. Het gebruikt het Gemini Decision 1-model om in één forward pass een vaste set opties te scoren en geeft een waarschijnlijkheid per optie terug, met nul gefactureerde outputtokens.
In deze tutorial voeren we dezelfde intent-classificatietaak uit op twee setups:
Gemini Decision 1 via de Decisions API
Gemini 3.5 Flash-Lite via de Interactions API, met gestructureerde JSON-output
We vergelijken ze op nauwkeurigheid, latentie, tokenverbruik, kosten en calibratie, en sturen daarna beide van 1 naar 100 vragen in één request.
Aan het eind van deze tutorial kun je:
De Decisions API aanroepen met choice-vragen en de kansen en confidencescores lezen
Een generatieve baseline bouwen met de Interactions API en een JSON-schema
Latentie, tokenverbruik en kosten voor beide aanpakken meten
Controleren of je de confidence van een model kunt vertrouwen, met een reliability-diagram en expected calibration error (ECE)
Bepalen wanneer een beslismodel beter bij je app past dan een generatief model
Je kunt de complete code draaien in deze Google Colab.
Beslismodellen vs. generatieve modellen
Voordat we kijken hoe elk werkt, definiëren we de twee termen.
Generatief model: Dit model produceert nieuwe content. Je geeft het een prompt en het schrijft een antwoord token voor token. Dat antwoord kan van alles zijn, zoals een antwoord, samenvatting, code of label. Gemini 3.5 Flash-Lite, zoals de meeste LLM’s die we in chatapps gebruiken, is een generatief model.
Beslismodel: Een beslismodel kiest uit de opties die jij definieert. Je geeft het een input en een vaste lijst met mogelijke antwoorden, en het vertelt je de waarschijnlijkheid van elke optie zonder een regel tekst te schrijven. Gemini Decision 1 is een beslismodel.
Hier is een voorbeeld.
Een klant schrijft aan een bank: "Mijn pas is nog niet aangekomen. Wanneer komt die?"
Als je een generatief model vraagt: "Wat wil deze klant?", dan kan het antwoorden:
“De klant wacht op een nieuwe pas en wil weten wanneer die arriveert.”
Dat is een goed antwoord voor een mens. Maar als je app het bericht naar het juiste team moet routeren, moet je code die zin nu omzetten naar een label. Je kunt een label afdwingen met een JSON-schema, maar het model schrijft het nog steeds token voor token.
Als je echter een beslismodel hetzelfde vraagt, geef je eerst de opties mee, zoals card_arrival, lost_or_stolen_card en exchange_rate. Het retourneert een waarschijnlijkheid per optie:
Je code kan dan direct op die waarschijnlijkheid handelen door naar het kaartteam te routeren als card_arrival boven een drempel ligt, en anders naar een mens te sturen. Kort gezegd:
Generatief model
Beslismodel
Retourneert
Tekst die het schrijft
Een waarschijnlijkheid voor elke door jou gedefinieerde optie
Mogelijke antwoorden
Open einde
Vaste set
Goed voor
Antwoorden, samenvattingen, uitleg en extractie
Routing, toolselectie, policychecks en beoordeling
In de praktijk gebruiken veel apps één generatief model voor beide taken. Dat testen we in de volgende sectie: of een beslismodel het classificatiegedeelte beter doet dan een generatief model.
Als je een generatief model als classifier gebruikt, schrijft het het antwoord token voor token. Voor een JSON-antwoord zoals het onze ziet de output er tijdens het genereren zo uit:
{
{"intent":
{"intent": "card_arrival",
{"intent": "card_arrival", "confidence": 0.95}Mogelijk gemaakt door
Elk token is een aparte decodiestap, en elk outputtoken wordt gefactureerd. Als je een confidencescore wilt, moet het model dat getal ook schrijven. Dat getal is de eigen gok van het model over zichzelf, geen waarschijnlijkheid gemeten uit zijn internals.
Een beslismodel slaat deze schrijfstap over. Je geeft de opties vooraf mee, en het scoort ze allemaal tegen de input in één forward pass. Het resultaat is een waarschijnlijkheid voor elke optie:
card_arrival 0.12
card_delivery_estimate 0.85
lost_or_stolen_card 0.01
...Mogelijk gemaakt door
Dit verandert drie dingen die je kunt meten:
Latentie: Er is geen decodlus, dus de latentie zou niet moeten toenemen met de lengte van het antwoord.
Kosten: Er zijn geen outputtokens om te factureren. Je betaalt alleen voor inputtokens, waaronder je vraagtekst en optieomschrijvingen.
Confidence: De confidence komt uit de waarschijnlijkheden zelf, dus die zou moeten volgen hoe vaak het model gelijk heeft.
De trade-off is dat je alleen gesloten vragen kunt stellen. Een beslismodel kan zijn antwoord niet uitleggen, geen waarde extraheren of vrije tekst schrijven.
Demo: een intent-classifier voor banken bouwen
In deze demo bouwen we een intent-classifier voor banken. We gebruiken de test-split van Banking77, een publieke dataset met klantberichten gelabeld met 77 intents, en houden 12 intents over die makkelijk met elkaar te verwarren zijn:
card_arrival en card_delivery_estimate
pending_card_payment, declined_card_payment en card_payment_fee_charged
pending_transfer, transfer_not_received_by_recipient en balance_not_updated_after_bank_transfer
lost_or_stolen_card, card_not_working, exchange_rate en top_up_failed
Vergelijkbare intents maken de taak lastiger, wat de confidencescores interessanter maakt om te bestuderen.
We draaien de classifier met beide modellen op twee manieren:
Eén bericht per request: 180 berichten (15 per intent), één voor één naar elk model gestuurd.
Veel vragen per request: N berichten in één gedeelde input, met één vraag per bericht, voor N = 1, 5, 10, 25, 50 en 100.
Hier zijn de instellingen die we voor beide modellen gelijk houdens:
Instelling
Gebruikte waarde
Waarom
Beslismodel
gemini-decision-1
Het model onder test
Generatief model
gemini-3.5-flash-lite
De kostenefficiënte generatieve baseline die in de launchpost-vergelijking is gebruikt
Flash-Lite-temperatuur
0.0
Verwijdert samplingruis uit de baseline
Flash-Lite denk-niveau
minimal
Houdt de vergelijking bij decoderen, niet redeneren
Outputformaat
JSON-schema met een enum van de 12 labels
Flash-Lite kan alleen een geldig label retourneren
Optieomschrijvingen
Eén korte zin per intent
Beide modellen zien dezelfde labeldefinities
Warmup-calls
2 per model
Houdt het opzetten van de verbinding buiten de metingen
Herhalingen (veel vragen per request)
3 per instelling
We rapporteren de mediaan, niet één enkele run
Let op: Dit zijn werkinstellingen voor deze demo, geen getunede instellingen voor een van beide modellen.
Een Colab-notebook (of een andere Python 3-omgeving)
google-genai versie 3.2 of hoger
De Decisions API heeft een kosteloze laag in Google AI Studio voor prototyping, dus je kunt het proberen voordat je betaalt. Ik draaide deze demo in Colab, maar gebruik gerust elke Python 3-omgeving.
Laten we beginnen met het installeren van de packages:
Hier is google-genai Google’s Python-SDK voor de Gemini API. Het geeft ons de methoden client.decisions.create en client.interactions.create, die requests sturen naar respectievelijk de Decisions API en de Interactions API. We gebruiken pandas om de dataset te laden en resultaten te organiseren, en matplotlib om figuren te plotten.
Vervolgens maken we de client aan. De Decisions API heeft de v1beta API-versie nodig:
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"Mogelijk gemaakt door
Hier leest genai.Client() de API-sleutel uit de GEMINI_API_KEY die onder secrets in Colab of als omgevingsvariabele is gezet, en http_options wijst naar de v1beta-API, waar de Decisions API draait.
Daarna laden we de Banking77-dataset en definiëren we onze 12 intents. Elke intent krijgt een beschrijving van één zin die beide modellen te zien krijgen:
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))Mogelijk gemaakt door
De bovenstaande code downloadt de Banking77 test-split als CSV en houdt alleen de rijen over die gelabeld zijn met een van onze 12 intents. Vervolgens worden er 15 berichten per intent bemonsterd met een vaste random seed, zodat je bij elke run hetzelfde sample krijgt. De laatste .sample(frac=1) schudt de rijen zodat de intents gemixt zijn.
Dit levert 180 berichten op, 15 per intent.
Stap 2: Classificeren met de Decisions API
Een choice-vraag neemt een dictionary die elke optie-ID mapt naar een beschrijving. We geven het bericht mee als input en stellen één vraag, met sleutel intent:
defdecide_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,}Mogelijk gemaakt door
De functie decide_intent() stuurt één bericht als input en één choice-vraag met onze 12 intents als opties. We timen de call met time.perf_counter(), en lezen vervolgens de topkeuze, confidence, alle optiewaarschijnlijkheden en tokencounts uit de response.
Elk antwoord bevat drie velden:
choice: De optie met de hoogste waarschijnlijkheid
probabilities: Eén waarschijnlijkheid per optie, somt op tot 1
confidence: De geschatte kans dat het topantwoord correct is
Het usage-object rapporteert inputtokens, en total_output_tokens is altijd 0.
Hier is het resultaat voor het eerste bericht in ons sample:
Het model verwarde twee vergelijkbare intents, maar de confidence van 0,846 toont enige onzekerheid. Het goede nieuws is dat de juiste intent, card_arrival, tweede werd met bijna alle resterende waarschijnlijkheid (ongeveer 0,15). Alle andere opties zaten rond nul.
Stap 3: Classificeren met Flash-Lite
Voor de generatieve baseline gebruiken we gestructureerde output met een enum van dezelfde 12 labels, zodat Flash-Lite alleen een geldig label kan retourneren. We vragen ook om een confidence tussen 0 en 1, wat is hoe de meeste apps een confidencescore uit een generatief model halen:
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"],}defgenerate_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,}Mogelijk gemaakt door
De functie generate_intent() bouwt een prompt met de 12 intents en hun beschrijvingen. Hij roept Flash-Lite aan met response_format ingesteld op ons JSON-schema, zodat de output geldige JSON moet zijn met een van de 12 labels. De temperatuur staat op 0 met minimal denk-niveau om het antwoord stabiel en kort te houden. We parsen daarna interaction.output_text met json.loads() en lezen de tokencounts uit interaction.usage.
Ik testte hetzelfde bericht als in de vorige stap met Flash-Lite, en het maakte dezelfde fout met hogere confidence:
Denktokens zijn 0, wat bevestigt dat minimal denken Flash-Lite tot alleen het schrijven van het antwoord beperkte. Flash-Lite gebruikte minder inputtokens dan Decision 1 (277 vs 337) omdat de Decisions API de optieomschrijvingen binnen de vraag als input meetelt.
Stap 4: Eén bericht per request classificeren
Laten we nu alle 180 berichten naar beide modellen sturen, één request per keer, na twee warmup-calls per model:
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"]Mogelijk gemaakt door
Deze loop stuurt elk bericht naar beide functies en slaat de voorspelling, confidence, latentie en tokencounts op als één rij. We zetten de rijen om in een DataFrame en voegen een kolom correct toe die markeert of elke voorspelling overeenkomt met het ware label.
Hier zijn de resultaten:
Metriek
Gemini Decision 1
Gemini 3.5 Flash-Lite
Nauwkeurigheid
84,4%
83,9%
Mediaanlatentie
325 ms
1.068 ms
p90-latentie
412 ms
6.483 ms
Traagste request
1,0 s
101,6 s
Requests boven 5 s
0 van 180
33 van 180
Gemiddelde inputtokens
339
279
Gemiddelde outputtokens
0
25
Hier zijn drie dingen die we leerden van deze metrics:
Nauwkeurigheid: Beide modellen waren ongeveer even nauwkeurig.
Latentie: Decision 1 was ongeveer 3x sneller op de mediaan en veel consistenter, terwijl Flash-Lite een lange staart van trage requests had.
Tokens: Decision 1 gebruikte meer inputtokens omdat de optieomschrijvingen meetellen als input, maar genereerde geen outputtokens.
Let op: Onze timing omvat de netwerk-roundtrip vanuit Colab, dus behandel dat verschil als setup-afhankelijk.
Stap 5: Calibratie controleren
Nauwkeurigheid vertelt hoe vaak een model gelijk heeft, maar calibratie vertelt of zijn confidence iets betekent of niet. Een model is goed gecalibreerd wanneer zijn confidence overeenkomt met zijn nauwkeurigheid; als het bijvoorbeeld 0,8 zegt bij een groep antwoorden, moet ongeveer 80% daarvan kloppen.
Om dit te meten, groeperen we voorspellingen in 10 confidence-bins en vergelijken we de gemiddelde confidence van elke bin met de nauwkeurigheid. Expected calibration error (ECE) is het gemiddelde verschil, gewogen naar hoeveel voorspellingen in elke bin vallen. Lager is beter.
defece(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.0for b inrange(n_bins):
mask = ids == b
if mask.sum():
total += mask.mean()*abs(conf[mask].mean()- correct[mask].mean())return totalMogelijk gemaakt door
De functie ece() plaatst elke voorspelling in een van de 10 bins op basis van zijn confidence (0 tot 0,1, 0,1 tot 0,2, enz.). Voor elke bin neemt hij het verschil tussen gemiddelde confidence en nauwkeurigheid, weegt dat met het aandeel voorspellingen in die bin en telt de resultaten op.
Zo compareren de twee modellen:
Metriek
Gemini Decision 1
Gemini 3.5 Flash-Lite
Nauwkeurigheid
84,4%
83,9%
Gemiddelde confidence
0,867
0,957
ECE
0,050
0,124
Gemiddelde confidence bij goed
0,901
0,966
Gemiddelde confidence bij fout
0,686
0,912
Figuur: Reliability-diagrammen voor beide modellen
De confidence van Decision 1 ligt dicht bij zijn nauwkeurigheid, met een ECE van 0,050. Hij is ook duidelijk lager wanneer het model fout zit (0,686) dan wanneer het goed zit (0,901).
Flash-Lite is overconfident. Het rapporteert gemiddeld 0,957 terwijl het 83,9% van de tijd gelijk heeft. Het gebruikte slechts 9 verschillende confidencewaarden over 180 antwoorden, en 158 daarvan waren 0,95 of hoger. Zelfs de foute antwoorden hadden gemiddeld 0,912. Het getal lijkt op een waarschijnlijkheid, maar het is de eigen schatting van het model, geschreven als tekst.
Calibratie is belangrijk wanneer je op de score handelt. Een veelvoorkomend patroon is om antwoorden boven een drempel te accepteren en de rest door te sturen naar een fallbackmodel of een mens:
Drempel
Decision 1: aandeel behouden
Decision 1: nauwkeurigheid op behouden
Flash-Lite: aandeel behouden
Flash-Lite: nauwkeurigheid op behouden
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%
Met Decision 1 werkt een hogere drempel zoals verwacht. Bij 0,9 houdt het 63% van de berichten over met 95,6% nauwkeurigheid. Bij Flash-Lite helpt de drempel nauwelijks, omdat de meeste foute antwoorden ook een hoge confidence hebben. De officiële docs raden aan een drempel te kiezen op basis van gelabelde voorbeelden van je eigen verkeer.
Stap 6: 100 berichten in één request classificeren
De Decisions API kan tot 1.000 vragen over één gedeelde input in een enkel request beantwoorden. Om dit te testen plaatsen we N klantberichten in één input en stellen één vraag per bericht.
Voor Decision 1 betekent dat N choice-vragen met sleutels m1 t/m mN:
defbuild_batch(n):
msgs = pool.iloc[:n]
shared ="Banking customer messages:\n"+"".join(f"Message {i +1}: {t}\n"for i, t inenumerate(msgs["text"]))return shared,list(msgs["category"])defdecide_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 inrange(n)}
result = client.decisions.create(
model=DECISION_MODEL,input=shared, questions=questions
)
preds =[result.answers[f"m{i +1}"].choice for i inrange(n)]return preds, gold, result.usageMogelijk gemaakt door
Hier nummerert de functie build_batch() de eerste N berichten en voegt ze samen tot één gedeelde input. Vervolgens maakt decide_batch() één choice-vraag per bericht met sleutels m1 t/m mN, stuurt ze allemaal in één request en leest één antwoord per sleutel terug.
Voor Flash-Lite sturen we dezelfde gedeelde input met een JSON-schema dat N velden heeft, elk beperkt tot 12 labels. Elk N gebruikt dezelfde berichten voor beide modellen, en elke instelling draait drie keer.
Vragen per request
Decision 1: mediaanlatentie
Flash-Lite: mediaanlatentie
Decision 1: inputtokens
Flash-Lite: input / outputtokens
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
Mislukt
15.100
Mislukt
100
59.095 ms
Mislukt
30.309
Mislukt
Tot 25 vragen bleef de mediaanlatentie van Decision 1 onder 550 ms. De mediaan van Flash-Lite groeide met N, van onder 1 s bij 1 tot 5 vragen naar 2,75 s bij 25, omdat het elk antwoord als outputtokens moet schrijven. Zelfs bij 50 vragen was de mediaan van Decision 1 592 ms, al duurde een van de drie runs 70 s.
Hier zijn twee punten om te overwegen:
Flash-Lite faalde bij 50 en 100 vragen: De "Mislukt"-rijen in de tabel hierboven zijn allemaal dezelfde 400-fout. Die geeft aan dat het schema "te veel toestanden voor serving" heeft. Een schema met 50 of meer velden, elk beperkt tot 12 labels, is meer dan de API accepteert.
Decision 1 vertraagde bij 100 vragen: Elke vraag herhaalt alle 12 optieomschrijvingen, ongeveer 300 tokens per vraag, dus het request kwam uit op 30.309 tokens, terwijl Google’s vlakke-latentieclaim geldt voor contexten tot 16K tokens.
Stap 7: Requests trimmen
Nu dringt zich een voor de hand liggende vraag op: kunnen we de vertraging en de fouten oplossen? Voor Decision 1 gebruiken we lege optieomschrijvingen (""). Voor Flash-Lite vragen we om één lijst van N labels in plaats van N losse velden:
# Decision 1: alleen optie-ID's, geen omschrijvingen"criteria":{k:""for k in LABELS}# Flash-Lite: één lijstveld in plaats van N velden
schema ={"type":"object","properties":{"intents":{"type":"array","items":{"type":"string","enum": LABELS},"minItems": n,"maxItems": n,}},"required":["intents"],}Mogelijk gemaakt door
Zo deed Decision 1 het met lege omschrijvingen:
Vragen per request
Mediaanlatentie
Nauwkeurigheid
Inputtokens
25
357 ms
84,0%
3.995
50
649 ms
78,0%
7.950
100
1.603 ms
83,0%
16.009
Het schrappen van de omschrijvingen halveerde grofweg de inputtokens. Bij 100 vragen kwam het request uit op circa 16K tokens en daalde de mediaanlatentie van 59 s naar 1,6 s. De nauwkeurigheid daalde iets bij 25 en 50 vragen, dus korte omschrijvingen zijn een beter midden dan geen, zeker bij vergelijkbare intents.
Het lijstschema hielp het Flash-Lite-model niet. Het werkte bij 25 vragen, maar faalde nog steeds bij 50 en 100.
Stap 8: Kosten vergelijken
Tot slot berekenen we de kosten op basis van de tokencounts die elke API teruggeeft, met prijzen uit de betaalde laag:
Model
Prijs input per 1M tokens
Prijs output per 1M tokens
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (inclusief denktokens)
defcost_per_request(model, input_tokens, output_tokens, thought_tokens):if model =="decision":return input_tokens *0.10/1e6return(input_tokens *0.30+(output_tokens + thought_tokens)*2.50)/1e6Mogelijk gemaakt door
De functie cost_per_request() vermenigvuldigt elke tokencount met de prijs per 1M tokens. Voor Decision 1 tellen alleen inputtokens mee. Voor Flash-Lite worden denktokens tegen de outputprijs gefactureerd, dus tellen we die op bij de outputtokens.
Hier zijn de kosten per 1.000 requests voor elke setup:
Setup
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 bericht per request
$0,034
$0,147
4,3x
5 vragen per request
$0,155
$0,271
1,7x
10 vragen per request
$0,306
$0,459
1,5x
25 vragen per request
$0,757
$1,088
1,4x
25 vragen, getrimde setups (Stap 7)
$0,400
$0,831
2,1x
50 vragen per request
$1,510
Mislukt
n.v.t.
100 vragen, lege omschrijvingen
$1,601
Mislukt
n.v.t.
Bij enkele berichten was Decision 1 4,3x goedkoper, maar het verschil krimpt naarmate je meer vragen in één request bundelt. De gedeelde input wordt in beide API’s één keer gefactureerd. Maar elke Decision 1-vraag draagt zijn eigen instructie en alle 12 optieomschrijvingen mee, terwijl Flash-Lite de labellijst maar één keer ziet en per antwoord een korte output betaalt. Bij 25 vragen gebruikte Decision 1 7.570 inputtokens tegenover 710 input en 350 outputtokens voor Flash-Lite.
Let op: De Decisions API ondersteunt geen contextcaching of de Batch API. Als je dezelfde input in meerdere requests stuurt, wordt die elke keer volledig gefactureerd. Dus als je veel vragen over dezelfde input hebt, stel ze in één request in plaats van ze over meerdere calls te verspreiden.
Wanneer welke aanpak gebruiken
Gebaseerd op bovenstaande runs past een beslismodel beter wanneer:
Het antwoord uit een vaste set opties komt, zoals intents, routes, tools of policylabels
De beslissing in het requestpad zit, waar elke gebruiker erop wacht
Je op confidence wilt handelen, bijvoorbeeld door onduidelijke gevallen door te sturen naar een fallback of een mens
Je veel onafhankelijke vragen over dezelfde input in één request moet stellen
Een generatief model past nog steeds beter wanneer:
Je een uitleg, een geëxtraheerde waarde of vrije tekst nodig hebt
De set mogelijke antwoorden open is of per request verandert
Je al een generatieve call op die input deed en de classificatie daaraan kunt toevoegen
Gebruik de Decisions API wanneer je nodig hebt
Gebruik de Interactions API wanneer je nodig hebt
Een ja/nee-kans, één optie uit een vaste set, of een rating op een vaste schaal
Gegenereerde tekst, samenvattingen of uitleg
Gecalibreerde waarschijnlijkheden die je kunt thresholden
Gëxtraheerde waarden of objecten die jouw JSON-schema volgen
Veel onafhankelijke checks over dezelfde input in één call
Toolcalls met argumenten
Lage latentie en nul outputtokenkosten
Meertrapsredenering
Slotgedachten
In deze tutorial bouwden we een intent-classifier voor banken met Gemini Decision 1 en Gemini 3.5 Flash-Lite, en berekenden we nauwkeurigheid, latentie, calibratie en kosten om de twee modellen te vergelijken. Vier takeaways uit de tutorial:
Nauwkeurigheid was gelijkspel: 84,4% voor Decision 1 en 83,9% voor Flash-Lite, met hetzelfde oordeel op 163 van de 180 berichten.
Decision 1 was sneller en voorspelbaarder: De mediaanlatentie was 325 ms tegenover 1.068 ms, en de traagste request duurde 1,0 s tegenover 101,6 s.
De confidence van Decision 1 was bruikbaar: De ECE was 0,050 tegenover 0,124, en het verhogen van de drempel naar 0,9 tilde de nauwkeurigheid op behouden antwoorden van 84,4% naar 95,6%. De zelfgerapporteerde confidence van Flash-Lite onderscheidde juiste en foute antwoorden nauwelijks.
Kosten en schalen hangen af van hoe je de vragen schrijft: Decision 1 was 4,3x goedkoper bij enkele berichten, maar elke vraag betaalt voor zijn optieomschrijvingen. Houd dus de totale input onder circa 16K tokens en houd optieomschrijvingen kort.
Deze resultaten komen uit één taak, één dataset en een klein aantal runs vanuit een Colab-notebook. Behandel ze als observaties uit een demo, niet als algemene prestatieclaims.
Ik ben een Google Developers Expert in ML (Gen AI), een Kaggle 3x Expert en een Women Techmakers Ambassador met meer dan 3 jaar ervaring in tech. In 2020 heb ik een healthtech-startup mee opgericht en ik volg een master computer science aan Georgia Tech, met als specialisatie machine learning.
FAQs
Wat is het verschil tussen de Decisions API en een generatieve API?⌄
Een generatieve API schrijft zijn antwoord token voor token en factureert elk outputtoken. De Decisions API scoort een vaste set opties in één forward pass en retourneert een waarschijnlijkheid voor elke optie. Er worden geen outputtokens gegenereerd, dus je betaalt alleen voor input.
Is Gemini Decision 1 nauwkeuriger dan Gemini 3.5 Flash-Lite?⌄
Niet in onze test. Op 180 bankberichten was de nauwkeurigheid 84,4% voor Decision 1 en 83,9% voor Flash-Lite. De verschillen die we maten zaten in latentie, calibratie en kosten.
Waarom gebruikt Decision 1 meer inputtokens dan Flash-Lite?⌄
De instructie van elke vraag en de optieomschrijvingen tellen mee als input. Met 12 beschreven opties leverde dat in onze test ongeveer 300 tokens per vraag op. Korte of lege optieomschrijvingen verlagen dit.
Blijft de latentie vlak als ik meer vragen toevoeg?⌄
In onze runs bleef de mediaan onder 650 ms tot en met 50 vragen. Bij 100 vragen met volledige optieomschrijvingen bereikte het request ongeveer 30K tokens en duurde 48 tot 59 s. Met lege omschrijvingen pasten dezelfde 100 vragen in circa 16K tokens en duurde het 1,6 s.
Welke vraagtypes ondersteunt de Decisions API?⌄
De Decisions API ondersteunt drie vraagtypes, waaronder noul voor ja/nee-checks, choice voor het kiezen van één optie uit 2 tot 255, en score voor beoordelen op een geordende rubric. Je kunt alle drie in één request combineren.
Analyze data smarter with Gemini in Google Sheets. Use AI-powered insights, formula suggestions, and automation to simplify spreadsheets and boost productivity.
De meeste LLM-apps zitten vol met kleine beslissingen: Welke tool moet de agent aanroepen? Welk model moet deze vraag afhandelen? Overtreedt dit bericht een policy?
Vandaag beantwoorden veel teams deze vragen door een generatief model te vragen het antwoord als tekst te schrijven, en die tekst vervolgens te parsen om een beslissing te nemen.
Google's Gemini Decisions API kiest een andere aanpak. Het gebruikt het Gemini Decision 1-model om in één forward pass een vaste set opties te scoren en geeft een waarschijnlijkheid per optie terug, met nul gefactureerde outputtokens.
In deze tutorial voeren we dezelfde intent-classificatietaak uit op twee setups:
We vergelijken ze op nauwkeurigheid, latentie, tokenverbruik, kosten en calibratie, en sturen daarna beide van 1 naar 100 vragen in één request.
Aan het eind van deze tutorial kun je:
De Decisions API aanroepen met
choice-vragen en de kansen en confidencescores lezenEen generatieve baseline bouwen met de Interactions API en een JSON-schema
Latentie, tokenverbruik en kosten voor beide aanpakken meten
Controleren of je de confidence van een model kunt vertrouwen, met een reliability-diagram en expected calibration error (ECE)
Bepalen wanneer een beslismodel beter bij je app past dan een generatief model
Je kunt de complete code draaien in deze Google Colab.
Beslismodellen vs. generatieve modellen
Voordat we kijken hoe elk werkt, definiëren we de twee termen.
Hier is een voorbeeld.
Een klant schrijft aan een bank: "Mijn pas is nog niet aangekomen. Wanneer komt die?"
Als je een generatief model vraagt: "Wat wil deze klant?", dan kan het antwoorden:
“De klant wacht op een nieuwe pas en wil weten wanneer die arriveert.”
Dat is een goed antwoord voor een mens. Maar als je app het bericht naar het juiste team moet routeren, moet je code die zin nu omzetten naar een label. Je kunt een label afdwingen met een JSON-schema, maar het model schrijft het nog steeds token voor token.
Als je echter een beslismodel hetzelfde vraagt, geef je eerst de opties mee, zoals
card_arrival,lost_or_stolen_cardenexchange_rate. Het retourneert een waarschijnlijkheid per optie:Je code kan dan direct op die waarschijnlijkheid handelen door naar het kaartteam te routeren als
card_arrivalboven een drempel ligt, en anders naar een mens te sturen. Kort gezegd:Generatief model
Beslismodel
Retourneert
Tekst die het schrijft
Een waarschijnlijkheid voor elke door jou gedefinieerde optie
Mogelijke antwoorden
Open einde
Vaste set
Goed voor
Antwoorden, samenvattingen, uitleg en extractie
Routing, toolselectie, policychecks en beoordeling
In de praktijk gebruiken veel apps één generatief model voor beide taken. Dat testen we in de volgende sectie: of een beslismodel het classificatiegedeelte beter doet dan een generatief model.
Als je een generatief model als classifier gebruikt, schrijft het het antwoord token voor token. Voor een JSON-antwoord zoals het onze ziet de output er tijdens het genereren zo uit:
Elk token is een aparte decodiestap, en elk outputtoken wordt gefactureerd. Als je een confidencescore wilt, moet het model dat getal ook schrijven. Dat getal is de eigen gok van het model over zichzelf, geen waarschijnlijkheid gemeten uit zijn internals.
Een beslismodel slaat deze schrijfstap over. Je geeft de opties vooraf mee, en het scoort ze allemaal tegen de input in één forward pass. Het resultaat is een waarschijnlijkheid voor elke optie:
Dit verandert drie dingen die je kunt meten:
De trade-off is dat je alleen gesloten vragen kunt stellen. Een beslismodel kan zijn antwoord niet uitleggen, geen waarde extraheren of vrije tekst schrijven.
Demo: een intent-classifier voor banken bouwen
In deze demo bouwen we een intent-classifier voor banken. We gebruiken de test-split van Banking77, een publieke dataset met klantberichten gelabeld met 77 intents, en houden 12 intents over die makkelijk met elkaar te verwarren zijn:
card_arrivalencard_delivery_estimatepending_card_payment,declined_card_paymentencard_payment_fee_chargedpending_transfer,transfer_not_received_by_recipientenbalance_not_updated_after_bank_transferlost_or_stolen_card,card_not_working,exchange_rateentop_up_failedVergelijkbare intents maken de taak lastiger, wat de confidencescores interessanter maakt om te bestuderen.
We draaien de classifier met beide modellen op twee manieren:
Hier zijn de instellingen die we voor beide modellen gelijk houdens:
Instelling
Gebruikte waarde
Waarom
Beslismodel
gemini-decision-1Het model onder test
Generatief model
gemini-3.5-flash-liteDe kostenefficiënte generatieve baseline die in de launchpost-vergelijking is gebruikt
Flash-Lite-temperatuur
0.0
Verwijdert samplingruis uit de baseline
Flash-Lite denk-niveau
minimalHoudt de vergelijking bij decoderen, niet redeneren
Outputformaat
JSON-schema met een
enumvan de 12 labelsFlash-Lite kan alleen een geldig label retourneren
Optieomschrijvingen
Eén korte zin per intent
Beide modellen zien dezelfde labeldefinities
Warmup-calls
2 per model
Houdt het opzetten van de verbinding buiten de metingen
Herhalingen (veel vragen per request)
3 per instelling
We rapporteren de mediaan, niet één enkele run
Let op: Dit zijn werkinstellingen voor deze demo, geen getunede instellingen voor een van beide modellen.
Stap 1: Vereisten en setup
Om mee te doen heb je nodig:
Een Gemini API-sleutel van Google AI Studio
Een Colab-notebook (of een andere Python 3-omgeving)
google-genaiversie 3.2 of hogerDe Decisions API heeft een kosteloze laag in Google AI Studio voor prototyping, dus je kunt het proberen voordat je betaalt. Ik draaide deze demo in Colab, maar gebruik gerust elke Python 3-omgeving.
Laten we beginnen met het installeren van de packages:
Hier is
google-genaiGoogle’s Python-SDK voor de Gemini API. Het geeft ons de methodenclient.decisions.createenclient.interactions.create, die requests sturen naar respectievelijk de Decisions API en de Interactions API. We gebruikenpandasom de dataset te laden en resultaten te organiseren, enmatplotlibom figuren te plotten.Vervolgens maken we de client aan. De Decisions API heeft de v1beta API-versie nodig:
Hier leest
genai.Client()de API-sleutel uit deGEMINI_API_KEYdie onder secrets in Colab of als omgevingsvariabele is gezet, enhttp_optionswijst naar de v1beta-API, waar de Decisions API draait.Daarna laden we de Banking77-dataset en definiëren we onze 12 intents. Elke intent krijgt een beschrijving van één zin die beide modellen te zien krijgen:
De bovenstaande code downloadt de Banking77 test-split als CSV en houdt alleen de rijen over die gelabeld zijn met een van onze 12 intents. Vervolgens worden er 15 berichten per intent bemonsterd met een vaste random seed, zodat je bij elke run hetzelfde sample krijgt. De laatste
.sample(frac=1)schudt de rijen zodat de intents gemixt zijn.Dit levert 180 berichten op, 15 per intent.
Stap 2: Classificeren met de Decisions API
Een
choice-vraag neemt een dictionary die elke optie-ID mapt naar een beschrijving. We geven het bericht mee alsinputen stellen één vraag, met sleutelintent:De functie
decide_intent()stuurt één bericht alsinputen éénchoice-vraag met onze 12 intents als opties. We timen de call mettime.perf_counter(), en lezen vervolgens de topkeuze, confidence, alle optiewaarschijnlijkheden en tokencounts uit de response.Elk antwoord bevat drie velden:
choice: De optie met de hoogste waarschijnlijkheidprobabilities: Eén waarschijnlijkheid per optie, somt op tot 1confidence: De geschatte kans dat het topantwoord correct isHet
usage-object rapporteert inputtokens, entotal_output_tokensis altijd 0.Hier is het resultaat voor het eerste bericht in ons sample:
Het model verwarde twee vergelijkbare intents, maar de confidence van 0,846 toont enige onzekerheid. Het goede nieuws is dat de juiste intent,
card_arrival, tweede werd met bijna alle resterende waarschijnlijkheid (ongeveer 0,15). Alle andere opties zaten rond nul.Stap 3: Classificeren met Flash-Lite
Voor de generatieve baseline gebruiken we gestructureerde output met een
enumvan dezelfde 12 labels, zodat Flash-Lite alleen een geldig label kan retourneren. We vragen ook om een confidence tussen 0 en 1, wat is hoe de meeste apps een confidencescore uit een generatief model halen:De functie
generate_intent()bouwt een prompt met de 12 intents en hun beschrijvingen. Hij roept Flash-Lite aan metresponse_formatingesteld op ons JSON-schema, zodat de output geldige JSON moet zijn met een van de 12 labels. De temperatuur staat op0metminimaldenk-niveau om het antwoord stabiel en kort te houden. We parsen daarnainteraction.output_textmetjson.loads()en lezen de tokencounts uitinteraction.usage.Ik testte hetzelfde bericht als in de vorige stap met Flash-Lite, en het maakte dezelfde fout met hogere confidence:
Denktokens zijn 0, wat bevestigt dat
minimaldenken Flash-Lite tot alleen het schrijven van het antwoord beperkte. Flash-Lite gebruikte minder inputtokens dan Decision 1 (277 vs 337) omdat de Decisions API de optieomschrijvingen binnen de vraag als input meetelt.Stap 4: Eén bericht per request classificeren
Laten we nu alle 180 berichten naar beide modellen sturen, één request per keer, na twee warmup-calls per model:
Deze loop stuurt elk bericht naar beide functies en slaat de voorspelling, confidence, latentie en tokencounts op als één rij. We zetten de rijen om in een DataFrame en voegen een kolom correct toe die markeert of elke voorspelling overeenkomt met het ware label.
Hier zijn de resultaten:
Metriek
Gemini Decision 1
Gemini 3.5 Flash-Lite
Nauwkeurigheid
84,4%
83,9%
Mediaanlatentie
325 ms
1.068 ms
p90-latentie
412 ms
6.483 ms
Traagste request
1,0 s
101,6 s
Requests boven 5 s
0 van 180
33 van 180
Gemiddelde inputtokens
339
279
Gemiddelde outputtokens
0
25
Hier zijn drie dingen die we leerden van deze metrics:
Let op: Onze timing omvat de netwerk-roundtrip vanuit Colab, dus behandel dat verschil als setup-afhankelijk.
Stap 5: Calibratie controleren
Nauwkeurigheid vertelt hoe vaak een model gelijk heeft, maar calibratie vertelt of zijn confidence iets betekent of niet. Een model is goed gecalibreerd wanneer zijn confidence overeenkomt met zijn nauwkeurigheid; als het bijvoorbeeld 0,8 zegt bij een groep antwoorden, moet ongeveer 80% daarvan kloppen.
Om dit te meten, groeperen we voorspellingen in 10 confidence-bins en vergelijken we de gemiddelde confidence van elke bin met de nauwkeurigheid. Expected calibration error (ECE) is het gemiddelde verschil, gewogen naar hoeveel voorspellingen in elke bin vallen. Lager is beter.
De functie
ece()plaatst elke voorspelling in een van de 10 bins op basis van zijn confidence (0 tot 0,1, 0,1 tot 0,2, enz.). Voor elke bin neemt hij het verschil tussen gemiddelde confidence en nauwkeurigheid, weegt dat met het aandeel voorspellingen in die bin en telt de resultaten op.Zo compareren de twee modellen:
Metriek
Gemini Decision 1
Gemini 3.5 Flash-Lite
Nauwkeurigheid
84,4%
83,9%
Gemiddelde confidence
0,867
0,957
ECE
0,050
0,124
Gemiddelde confidence bij goed
0,901
0,966
Gemiddelde confidence bij fout
0,686
0,912
Figuur: Reliability-diagrammen voor beide modellen
De confidence van Decision 1 ligt dicht bij zijn nauwkeurigheid, met een ECE van 0,050. Hij is ook duidelijk lager wanneer het model fout zit (0,686) dan wanneer het goed zit (0,901).
Flash-Lite is overconfident. Het rapporteert gemiddeld 0,957 terwijl het 83,9% van de tijd gelijk heeft. Het gebruikte slechts 9 verschillende confidencewaarden over 180 antwoorden, en 158 daarvan waren 0,95 of hoger. Zelfs de foute antwoorden hadden gemiddeld 0,912. Het getal lijkt op een waarschijnlijkheid, maar het is de eigen schatting van het model, geschreven als tekst.
Calibratie is belangrijk wanneer je op de score handelt. Een veelvoorkomend patroon is om antwoorden boven een drempel te accepteren en de rest door te sturen naar een fallbackmodel of een mens:
Drempel
Decision 1: aandeel behouden
Decision 1: nauwkeurigheid op behouden
Flash-Lite: aandeel behouden
Flash-Lite: nauwkeurigheid op behouden
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%
Met Decision 1 werkt een hogere drempel zoals verwacht. Bij 0,9 houdt het 63% van de berichten over met 95,6% nauwkeurigheid. Bij Flash-Lite helpt de drempel nauwelijks, omdat de meeste foute antwoorden ook een hoge confidence hebben. De officiële docs raden aan een drempel te kiezen op basis van gelabelde voorbeelden van je eigen verkeer.
Stap 6: 100 berichten in één request classificeren
De Decisions API kan tot 1.000 vragen over één gedeelde input in een enkel request beantwoorden. Om dit te testen plaatsen we N klantberichten in één input en stellen één vraag per bericht.
Voor Decision 1 betekent dat N
choice-vragen met sleutelsm1t/mmN:Hier nummerert de functie
build_batch()de eerste N berichten en voegt ze samen tot één gedeelde input. Vervolgens maaktdecide_batch()éénchoice-vraag per bericht met sleutelsm1t/mmN, stuurt ze allemaal in één request en leest één antwoord per sleutel terug.Voor Flash-Lite sturen we dezelfde gedeelde input met een JSON-schema dat N velden heeft, elk beperkt tot 12 labels. Elk N gebruikt dezelfde berichten voor beide modellen, en elke instelling draait drie keer.
Vragen per request
Decision 1: mediaanlatentie
Flash-Lite: mediaanlatentie
Decision 1: inputtokens
Flash-Lite: input / outputtokens
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
Mislukt
15.100
Mislukt
100
59.095 ms
Mislukt
30.309
Mislukt
Tot 25 vragen bleef de mediaanlatentie van Decision 1 onder 550 ms. De mediaan van Flash-Lite groeide met N, van onder 1 s bij 1 tot 5 vragen naar 2,75 s bij 25, omdat het elk antwoord als outputtokens moet schrijven. Zelfs bij 50 vragen was de mediaan van Decision 1 592 ms, al duurde een van de drie runs 70 s.
Hier zijn twee punten om te overwegen:
Stap 7: Requests trimmen
Nu dringt zich een voor de hand liggende vraag op: kunnen we de vertraging en de fouten oplossen? Voor Decision 1 gebruiken we lege optieomschrijvingen (""). Voor Flash-Lite vragen we om één lijst van N labels in plaats van N losse velden:
Zo deed Decision 1 het met lege omschrijvingen:
Vragen per request
Mediaanlatentie
Nauwkeurigheid
Inputtokens
25
357 ms
84,0%
3.995
50
649 ms
78,0%
7.950
100
1.603 ms
83,0%
16.009
Het schrappen van de omschrijvingen halveerde grofweg de inputtokens. Bij 100 vragen kwam het request uit op circa 16K tokens en daalde de mediaanlatentie van 59 s naar 1,6 s. De nauwkeurigheid daalde iets bij 25 en 50 vragen, dus korte omschrijvingen zijn een beter midden dan geen, zeker bij vergelijkbare intents.
Het lijstschema hielp het Flash-Lite-model niet. Het werkte bij 25 vragen, maar faalde nog steeds bij 50 en 100.
Stap 8: Kosten vergelijken
Tot slot berekenen we de kosten op basis van de tokencounts die elke API teruggeeft, met prijzen uit de betaalde laag:
Model
Prijs input per 1M tokens
Prijs output per 1M tokens
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (inclusief denktokens)
De functie
cost_per_request()vermenigvuldigt elke tokencount met de prijs per 1M tokens. Voor Decision 1 tellen alleen inputtokens mee. Voor Flash-Lite worden denktokens tegen de outputprijs gefactureerd, dus tellen we die op bij de outputtokens.Hier zijn de kosten per 1.000 requests voor elke setup:
Setup
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 bericht per request
$0,034
$0,147
4,3x
5 vragen per request
$0,155
$0,271
1,7x
10 vragen per request
$0,306
$0,459
1,5x
25 vragen per request
$0,757
$1,088
1,4x
25 vragen, getrimde setups (Stap 7)
$0,400
$0,831
2,1x
50 vragen per request
$1,510
Mislukt
n.v.t.
100 vragen, lege omschrijvingen
$1,601
Mislukt
n.v.t.
Bij enkele berichten was Decision 1 4,3x goedkoper, maar het verschil krimpt naarmate je meer vragen in één request bundelt. De gedeelde input wordt in beide API’s één keer gefactureerd. Maar elke Decision 1-vraag draagt zijn eigen instructie en alle 12 optieomschrijvingen mee, terwijl Flash-Lite de labellijst maar één keer ziet en per antwoord een korte output betaalt. Bij 25 vragen gebruikte Decision 1 7.570 inputtokens tegenover 710 input en 350 outputtokens voor Flash-Lite.
Let op: De Decisions API ondersteunt geen contextcaching of de Batch API. Als je dezelfde input in meerdere requests stuurt, wordt die elke keer volledig gefactureerd. Dus als je veel vragen over dezelfde input hebt, stel ze in één request in plaats van ze over meerdere calls te verspreiden.
Wanneer welke aanpak gebruiken
Gebaseerd op bovenstaande runs past een beslismodel beter wanneer:
Een generatief model past nog steeds beter wanneer:
Gebruik de Decisions API wanneer je nodig hebt
Gebruik de Interactions API wanneer je nodig hebt
Een ja/nee-kans, één optie uit een vaste set, of een rating op een vaste schaal
Gegenereerde tekst, samenvattingen of uitleg
Gecalibreerde waarschijnlijkheden die je kunt thresholden
Gëxtraheerde waarden of objecten die jouw JSON-schema volgen
Veel onafhankelijke checks over dezelfde input in één call
Toolcalls met argumenten
Lage latentie en nul outputtokenkosten
Meertrapsredenering
Slotgedachten
In deze tutorial bouwden we een intent-classifier voor banken met Gemini Decision 1 en Gemini 3.5 Flash-Lite, en berekenden we nauwkeurigheid, latentie, calibratie en kosten om de twee modellen te vergelijken. Vier takeaways uit de tutorial:
Deze resultaten komen uit één taak, één dataset en een klein aantal runs vanuit een Colab-notebook. Behandel ze als observaties uit een demo, niet als algemene prestatieclaims.