Gemini Decisions API: Testarea noului model de decizie de la Google la latență și cost
Află cum Gemini Decision 1 punctează opțiuni fixe fără a genera text, construiește un clasificator de intenții bancare cu Decisions API și compară-l cu Gemini 3.5 Flash-Lite la acuratețe, latență, calibrare și cost.
Majoritatea aplicațiilor bazate pe LLM sunt pline de mici decizii: Ce unealtă ar trebui să apeleze agentul? Ce model ar trebui să preia această interogare? Încalcă acest mesaj o politică?
Astăzi, multe echipe răspund la aceste întrebări cerând unui model generativ să scrie răspunsul ca text, apoi analizând acel text pentru a lua o decizie.
Gemini Decisions API de la Google abordează altfel problema. Folosește modelul Gemini Decision 1 pentru a puncta un set fix de opțiuni într-un singur forward pass și întoarce o probabilitate pentru fiecare opțiune, cu zero tokeni de ieșire facturați.
În acest tutorial, vom rula aceeași sarcină de clasificare a intențiilor pe două configurații:
Gemini Decision 1 prin Decisions API
Gemini 3.5 Flash-Lite prin Interactions API, folosind ieșire JSON structurată
Le vom compara la acuratețe, latență, utilizare de tokeni, cost și calibrare, apoi vom împinge ambele de la 1 la 100 de întrebări într-o singură cerere.
La finalul acestui tutorial, vei ști cum să:
Apelezi Decisions API cu întrebări choice și să citești probabilitățile și scorurile de încredere
Construiești un baseline generativ cu Interactions API și un schelet JSON
Măsori latența, utilizarea de tokeni și costul pentru ambele abordări
Verifici dacă încrederea unui model poate fi de încredere, folosind un diagramă de fiabilitate și eroarea de calibrare așteptată (ECE)
Decizi când un model de decizie se potrivește aplicației tale mai bine decât unul generativ
Înainte să vedem cum funcționează fiecare, să definim cei doi termeni.
Model generativ: Acest model produce conținut nou. Îi dai un prompt și scrie un răspuns token cu token. Răspunsul poate fi orice: un răspuns, un rezumat, cod sau o etichetă. Gemini 3.5 Flash-Lite, ca majoritatea LLM-urilor folosite în aplicații de chat, este un model generativ.
Model de decizie: Un model de decizie alege din opțiunile pe care le definești. Îi dai un input și o listă fixă de răspunsuri posibile, iar el îți spune probabilitatea fiecărei opțiuni fără să scrie niciun rând de text. Gemini Decision 1 este un model de decizie.
Iată un exemplu.
Un client scrie unei bănci: „Cardul meu încă n-a sosit. Când va veni?”
Dacă întrebi un model generativ „Ce vrea acest client?”, ți-ar putea răspunde:
„Clientul așteaptă un card nou și vrea să știe când va sosi.”
E un răspuns bun pentru un om. Dar dacă aplicația ta trebuie să direcționeze mesajul către echipa potrivită, codul tău trebuie acum să transforme acea propoziție într-o etichetă. Poți impune o etichetă cu un schelet JSON, dar modelul tot o scrie token cu token.
Însă, dacă întrebi un model de decizie același lucru, îi dai mai întâi opțiunile, precum card_arrival, lost_or_stolen_card și exchange_rate. Îți întoarce o probabilitate pentru fiecare:
card_arrival 0.91
lost_or_stolen_card 0.06
exchange_rate 0.03Funcționează cu
Codul tău poate apoi acționa direct pe acea probabilitate, direcționând către echipa de carduri dacă card_arrival este peste un prag și trimițând la un om dacă nu. Pe scurt:
Model generativ
Model de decizie
Returnează
Text scris de el
O probabilitate pentru fiecare opțiune definită
Răspunsuri posibile
Deschise
Set fix
Bun pentru
Răspunsuri, rezumate, explicații și extragere
Rutare, selecție de unelte, verificări de politici și notare
În practică, multe aplicații folosesc un model generativ pentru ambele roluri. Asta vom testa în secțiunea următoare: dacă un model de decizie face partea de clasificare mai bine decât un model generativ.
Când folosești un model generativ ca clasificator, el scrie răspunsul token cu token. Pentru un răspuns JSON ca al nostru, ieșirea arată așa pe măsură ce este generată:
{
{"intent":
{"intent": "card_arrival",
{"intent": "card_arrival", "confidence": 0.95}Funcționează cu
Fiecare token este un pas de decodare separat, iar fiecare token de ieșire este facturat. Dacă vrei un scor de încredere, modelul trebuie să scrie și acel număr. Acel număr este presupunerea modelului despre el însuși, nu o probabilitate măsurată din mecanismele sale interne.
Un model de decizie, însă, sare peste pasul de scriere. Îi dai opțiunile din start și punctează toate opțiunile față de input într-un singur forward pass. Rezultatul este o probabilitate pentru fiecare opțiune:
card_arrival 0.12
card_delivery_estimate 0.85
lost_or_stolen_card 0.01
...Funcționează cu
Asta schimbă trei lucruri pe care le poți măsura:
Latență: Nu există un buclă de decodare, deci latența nu ar trebui să crească odată cu lungimea răspunsului.
Cost: Nu există tokeni de ieșire de facturat. Plătești doar pentru tokenii de intrare, care includ textul întrebării și descrierile opțiunilor.
Încredere: Încrederea vine din probabilitățile în sine, deci ar trebui să urmărească cât de des modelul are dreptate.
Compromisul este că poți pune doar întrebări cu set închis. Un model de decizie nu își poate explica răspunsul, nu poate extrage o valoare sau scrie text liber.
Demo: Construirea unui clasificator de intenții bancare
În acest demo, vom construi un clasificator de intenții bancare. Vom folosi splitul de test din Banking77, un set de date public cu mesaje de clienți etichetate cu 77 de intenții, și vom păstra 12 intenții ușor de confundat între ele:
card_arrival și card_delivery_estimate
pending_card_payment, declined_card_payment și card_payment_fee_charged
pending_transfer, transfer_not_received_by_recipient și balance_not_updated_after_bank_transfer
lost_or_stolen_card, card_not_working, exchange_rate și top_up_failed
Intențiile similare fac sarcina mai grea, ceea ce face scorurile de încredere mai interesante de studiat.
Vom rula clasificatorul cu ambele modele în două moduri:
Un mesaj per cerere: 180 de mesaje (15 per intenție), trimise fiecărui model pe rând.
Multe întrebări per cerere: N mesaje plasate într-un singur input comun, cu o întrebare per mesaj, pentru N = 1, 5, 10, 25, 50 și 100.
Iată setările pe care le păstrăm la fel pentru ambele modeles:
Setare
Valoare folosită
De ce
Model de decizie
gemini-decision-1
Modelul testat
Model generativ
gemini-3.5-flash-lite
Baseline-ul generativ eficient ca cost folosit în comparația din anunțul de lansare
Temperatura Flash-Lite
0.0
Elimină zgomotul de eșantionare din baseline
Nivelul de „gândire” Flash-Lite
minimal
Păstrează comparația la partea de decodare, nu de raționare
Format ieșire
Schelet JSON cu un enum al celor 12 etichete
Flash-Lite poate întoarce doar o etichetă validă
Descrieri ale opțiunilor
O propoziție scurtă per intenție
Ambele modele văd aceleași definiții ale etichetelor
Apeluri de încălzire
2 per model
Exclude configurarea conexiunii din măsurători
Repetări (multe întrebări per cerere)
3 per setare
Raportăm mediana, nu o singură rulare
Notă: Acestea sunt setări de lucru pentru acest demo, nu setări optimizate pentru vreunul dintre modele.
Decisions API are un nivel fără cost în Google AI Studio pentru prototipare, așa că îl poți încerca înainte să plătești. Eu am rulat acest demo în Colab, dar poți folosi orice mediu Python 3.
Să începem prin a instala pachetele:
!pip install-q-U"google-genai>=3.2" pandas matplotlibFuncționează cu
Aici, google-genai este SDK-ul Python de la Google pentru Gemini API. Ne oferă metodele client.decisions.create și client.interactions.create, care trimit cereri către Decisions API și Interactions API. Folosim pandas pentru a încărca setul de date și a organiza rezultatele, iar matplotlib pentru a desena figurile.
În continuare, creăm clientul. Decisions API are nevoie de versiunea de 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"Funcționează cu
Aici, genai.Client() citește cheia API din GEMINI_API_KEY setată la „secrets” în Colab sau ca variabilă de mediu, iar http_options îl indică spre API-ul v1beta, unde se află Decisions API.
Apoi vom încărca setul de date Banking77 și vom defini cele 12 intenții. Fiecare intenție primește o descriere într-o propoziție pe care o vor vedea ambele modele:
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))Funcționează cu
Fragmentul de cod de mai sus descarcă splitul de test Banking77 ca fișier CSV și păstrează doar rândurile etichetate cu una dintre cele 12 intenții. Apoi eșantionează 15 mesaje per intenție cu un seed fix, astfel încât să obții același eșantion la fiecare rulare. Ultimul .sample(frac=1) amestecă rândurile pentru a combina intențiile.
Asta ne oferă 180 de mesaje, 15 per intenție.
Pasul 2: Clasifică cu Decisions API
O întrebare de tip choice primește un dicționar care map-ează fiecare ID de opțiune la o descriere. Trimitem mesajul ca input și punem o singură întrebare, cu cheia 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,}Funcționează cu
Funcția decide_intent() trimite un mesaj ca input și o întrebare choice cu cele 12 intenții ca opțiuni. Cronometrăm apelul cu time.perf_counter(), apoi citim opțiunea de top, încrederea, toate probabilitățile opțiunilor și numărul de tokeni din răspuns.
Fiecare răspuns conține trei câmpuri:
choice: Opțiunea cu cea mai mare probabilitate
probabilities: O probabilitate per opțiune, care însumează 1
confidence: Probabilitatea estimată ca răspunsul de top să fie corect
Obiectul usage raportează tokenii de intrare, iar total_output_tokens este mereu 0.
Iată rezultatul pentru primul mesaj din eșantionul nostru:
Modelul a confundat două intenții similare, dar încrederea de 0,846 arată ceva incertitudine. Partea bună este că intenția corectă, card_arrival, a venit pe locul al doilea cu aproape toată probabilitatea rămasă (aprox. 0,15). Toate celelalte opțiuni au fost aproape de zero.
Pasul 3: Clasifică cu Flash-Lite
Pentru baseline-ul generativ, folosim ieșire structurată cu un enum al acelorași 12 etichete, astfel încât Flash-Lite să poată întoarce doar o etichetă validă. Cerem și o încredere între 0 și 1, ceea ce este modul în care majoritatea aplicațiilor obțin un scor de încredere de la un model generativ:
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,}Funcționează cu
Funcția generate_intent() construiește un prompt cu cele 12 intenții și descrierile lor. Apelează Flash-Lite cu response_format setat la scheletul nostru JSON, astfel încât ieșirea trebuie să fie JSON valid cu una dintre cele 12 etichete. Temperatura este setată la 0 cu nivel de gândire minimal pentru a păstra răspunsul stabil și scurt. Apoi analizăm interaction.output_text cu json.loads() și citim numărătorile de tokeni din interaction.usage.
Am testat același mesaj ca la pasul anterior cu Flash-Lite și a făcut aceeași greșeală, cu o încredere mai mare:
Tokenii de „gândire” sunt 0, ceea ce confirmă că nivelul minimal a făcut ca Flash-Lite să scrie doar răspunsul. Flash-Lite a folosit mai puțini tokeni de intrare decât Decision 1 (277 vs 337) pentru că Decisions API contorizează descrierile opțiunilor din interiorul întrebării ca intrare.
Pasul 4: Clasifică un mesaj per cerere
Acum, să trimitem toate cele 180 de mesaje la ambele modele, câte o cerere pe rând, după câte două apeluri de încălzire fiecare:
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"]Funcționează cu
Acest buclă trimite fiecare mesaj la ambele funcții și salvează predicția, încrederea, latența și numărătorile de tokeni ca un rând. Apoi transformăm rândurile într-un DataFrame și adăugăm o coloană „correct” care marchează dacă fiecare predicție corespunde etichetei reale.
Iată rezultatele:
Metrică
Gemini Decision 1
Gemini 3.5 Flash-Lite
Acuratețe
84,4%
83,9%
Latență mediană
325 ms
1.068 ms
Latență p90
412 ms
6.483 ms
Cea mai lentă cerere
1,0 s
101,6 s
Cereri peste 5 s
0 din 180
33 din 180
Tokeni medii de intrare
339
279
Tokeni medii de ieșire
0
25
Iată trei lucruri pe care le-am învățat din aceste valori:
Acuratețe: Ambele modele au fost la fel de precise, aproximativ.
Latență: Decision 1 a fost cam de 3 ori mai rapid la mediană și mult mai consistent, în timp ce Flash-Lite a avut o „coadă” lungă de cereri lente.
Tokeni: Decision 1 a folosit mai mulți tokeni de intrare deoarece descrierile opțiunilor se contorizează ca intrare, dar nu a generat tokeni de ieșire.
Notă: Timpii includ drumul prin rețea din Colab, așa că tratează diferența ca dependentă de configurare.
Pasul 5: Verifică calibrarea
Acuratețea ne spune cât de des un model are dreptate, dar calibrarea ne spune dacă încrederea lui are sens sau nu. Un model este bine calibrat când încrederea lui se potrivește cu acuratețea, adică, dacă spune 0,8 pe un grup de răspunsuri, aproximativ 80% dintre ele ar trebui să fie corecte.
Pentru a măsura asta, grupăm predicțiile în 10 intervale de încredere și comparăm încrederea medie a fiecărui interval cu acuratețea lui. Expected calibration error (ECE) este diferența medie, ponderată după câte predicții cad în fiecare interval. Mai mic este mai bine.
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 totalFuncționează cu
Funcția ece() plasează fiecare predicție într-unul dintre cele 10 intervale după încredere (0–0,1, 0,1–0,2 etc.). Pentru fiecare interval, ia diferența dintre încrederea medie și acuratețe, o ponderizează cu ponderea predicțiilor din acel interval și adună rezultatele.
Iată cum se compară cele două modele:
Metrică
Gemini Decision 1
Gemini 3.5 Flash-Lite
Acuratețe
84,4%
83,9%
Încredere medie
0,867
0,957
ECE
0,050
0,124
Încredere medie când e corect
0,901
0,966
Încredere medie când e greșit
0,686
0,912
Figura: Diagrame de fiabilitate pentru ambele modele
Încrederea lui Decision 1 este aproape de acuratețea lui, cu un ECE de 0,050. Este, de asemenea, evident mai mică atunci când modelul greșește (0,686) decât atunci când are dreptate (0,901).
Flash-Lite este prea încrezător. Raportează 0,957 în medie, deși are dreptate 83,9% din timp. A folosit doar 9 valori distincte de încredere pe 180 de răspunsuri, iar 158 dintre ele au fost 0,95 sau mai mari. Chiar și răspunsurile greșite au avut în medie 0,912. Numărul arată ca o probabilitate, dar este estimarea modelului, scrisă ca text.
Calibrarea contează când acționezi pe baza scorului. Un tipar comun este să accepți răspunsuri peste un prag de încredere și să trimiți restul către un model fallback sau un om:
Prag
Decision 1: pondere păstrată
Decision 1: acuratețe pe cele păstrate
Flash-Lite: pondere păstrată
Flash-Lite: acuratețe pe cele păstrate
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%
Cu Decision 1, un prag mai înalt funcționează cum te-ai aștepta. La 0,9, păstrează 63% dintre mesaje la 95,6% acuratețe. Cu Flash-Lite, pragul ajută abia, pentru că majoritatea răspunsurilor greșite au și ele încredere mare. Documentația oficială recomandă alegerea unui prag din exemple etichetate din traficul tău.
Pasul 6: Clasifică 100 de mesaje într-o singură cerere
Decisions API poate răspunde la până la 1.000 de întrebări despre un input comun într-o singură cerere. Pentru a testa asta, punem N mesaje de la clienți într-un singur input și punem o întrebare per mesaj.
Pentru Decision 1, asta înseamnă N întrebări choice cu cheile de la m1 la 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.usageFuncționează cu
Aici, funcția build_batch() numerotează primele N mesaje și le unește într-un singur input comun. Apoi decide_batch() creează o întrebare choice per mesaj, cu cheile de la m1 la mN, le trimite pe toate într-o singură cerere și citește câte un răspuns per cheie.
Pentru Flash-Lite, trimitem același input comun cu un schelet JSON care are N câmpuri, fiecare limitat la 12 etichete. Fiecare N folosește aceleași mesaje pentru ambele modele, iar fiecare setare rulează de trei ori.
Întrebări per cerere
Decision 1: latență mediană
Flash-Lite: latență mediană
Decision 1: tokeni intrare
Flash-Lite: tokeni intrare / ieșire
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
Eșuat
15.100
Eșuat
100
59.095 ms
Eșuat
30.309
Eșuat
Până la 25 de întrebări, latența mediană a lui Decision 1 a rămas sub 550 ms. Mediana lui Flash-Lite a crescut cu N, de la sub 1 s la 1–5 întrebări la 2,75 s la 25, pentru că trebuie să scrie fiecare răspuns ca tokeni de ieșire. Chiar și la 50 de întrebări, mediana lui Decision 1 a fost 592 ms, deși una dintre cele trei rulări a durat 70 s.
Iată două puncte-cheie de analizat:
Flash-Lite a eșuat la 50 și 100 de întrebări: Rândurile „Eșuat” din tabel sunt același eroare 400. Arată că schema „are prea multe stări pentru servire”. O schemă cu 50+ câmpuri, fiecare limitat la 12 etichete, depășește ce acceptă API-ul.
Decision 1 a încetinit la 100 de întrebări: Fiecare întrebare repetă toate cele 12 descrieri ale opțiunilor, aproximativ 300 de tokeni per întrebare, deci cererea a ajuns la 30.309 tokeni, în timp ce afirmația Google despre latență plată acoperă contexte de până la 16K tokeni.
Pasul 7: Optimizează cererile
Acum apare o întrebare evidentă: putem remedia încetinirea și eșecurile? Pentru Decision 1, folosim descrieri goale ale opțiunilor (""). Pentru Flash-Lite, cerem o singură listă de N etichete în loc de N câmpuri separate:
# Decision 1: doar ID-urile opțiunilor, fără descrieri"criteria":{k:""for k in LABELS}# Flash-Lite: un singur câmp-listă în loc de N câmpuri
schema ={"type":"object","properties":{"intents":{"type":"array","items":{"type":"string","enum": LABELS},"minItems": n,"maxItems": n,}},"required":["intents"],}Funcționează cu
Iată cum a mers Decision 1 cu descrieri goale:
Întrebări per cerere
Latență mediană
Acuratețe
Tokeni de intrare
25
357 ms
84,0%
3.995
50
649 ms
78,0%
7.950
100
1.603 ms
83,0%
16.009
Renunțarea la descrieri a înjumătățit aproximativ tokenii de intrare. La 100 de întrebări, cererea a coborât la ~16K tokeni, iar mediana latenței a scăzut de la 59 s la 1,6 s. Acuratețea a scăzut puțin la 25 și 50 de întrebări, așa că descrierile scurte sunt un compromis mai bun decât lipsa lor, mai ales pentru intenții similare.
Schema de listă nu a ajutat modelul Flash-Lite. A funcționat la 25 de întrebări, dar tot a eșuat la 50 și 100.
Pasul 8: Compară costul
În final, calculăm costul din numărătorile de tokeni pe care le întoarce fiecare API, folosind prețuri din nivelul plătit:
Model
Preț intrare per 1M tokeni
Preț ieșire per 1M tokeni
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (inclusiv tokeni de gândire)
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)/1e6Funcționează cu
Funcția cost_per_request() înmulțește fiecare număr de tokeni cu prețul per 1M tokeni. Pentru Decision 1, contează doar tokenii de intrare. Pentru Flash-Lite, tokenii de „gândire” sunt facturați la prețul ieșirii, deci îi adăugăm la tokenii de ieșire.
Iată costul per 1.000 de cereri pentru fiecare configurare:
Configurare
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 mesaj per cerere
$0,034
$0,147
4,3x
5 întrebări per cerere
$0,155
$0,271
1,7x
10 întrebări per cerere
$0,306
$0,459
1,5x
25 întrebări per cerere
$0,757
$1,088
1,4x
25 întrebări, configurații optimizate (Pasul 7)
$0,400
$0,831
2,1x
50 întrebări per cerere
$1,510
Eșuat
n/a
100 întrebări, descrieri goale
$1,601
Eșuat
n/a
Pe mesaje singulare, Decision 1 a fost de 4,3x mai ieftin, dar diferența se micșorează pe măsură ce grupezi mai multe întrebări într-o singură cerere. Inputul comun este facturat o dată în ambele API-uri. Dar fiecare întrebare Decision 1 poartă propria instrucțiune și toate cele 12 descrieri ale opțiunilor, în timp ce Flash-Lite vede lista etichetelor o singură dată și plătește pentru o ieșire scurtă per răspuns. La 25 de întrebări, Decision 1 a folosit 7.570 tokeni de intrare față de 710 tokeni de intrare și 350 de ieșire pentru Flash-Lite.
Notă: Decisions API nu suportă context caching sau Batch API. Dacă trimiți același input în mai multe cereri, este facturat integral de fiecare dată. Așadar, când ai multe întrebări despre același input, pune-le într-o singură cerere, nu împrăștiate pe mai multe apeluri.
Când să folosești fiecare abordare
Pe baza rulărilor de mai sus, un model de decizie se potrivește mai bine când:
Răspunsul vine dintr-un set fix de opțiuni, ca intenții, rute, unelte sau etichete de politici
Decizia este pe calea cererii, unde fiecare utilizator așteaptă
Vrei să acționezi pe baza încrederii, de exemplu, trimițând cazurile neclare către un fallback sau un om
Trebuie să pui multe întrebări independente despre același input într-o singură cerere
Un model generativ tot se potrivește mai bine când:
Ai nevoie de o explicație, o valoare extrasă sau orice text liber
Setul de răspunsuri posibile este deschis sau se schimbă per cerere
Ai făcut deja un apel generativ pe acel input și poți adăuga clasificarea la el
Folosește Decisions API când ai nevoie de
Folosește Interactions API când ai nevoie de
O probabilitate da/nu, o opțiune dintr-un set fix sau un scor pe o scală fixă
Text generat, rezumate sau explicații
Probabilități calibrate pe care le poți pragui
Valori sau obiecte extrase care urmează propriul tău schelet JSON
Multe verificări independente pe același input într-un apel
Apeluri de unelte cu argumente
Latență mică și cost zero pentru tokenii de ieșire
Raționament în mai mulți pași
Gânduri de final
În acest tutorial, am construit un clasificator de intenții bancare cu Gemini Decision 1 și Gemini 3.5 Flash-Lite, apoi am calculat acuratețea, latența, calibrarea și costul pentru a compara cele două modele. Iată patru concluzii din tutorial:
Acuratețea a fost la egalitate: 84,4% pentru Decision 1 și 83,9% pentru Flash-Lite, cu același verdict pe 163 din 180 de mesaje.
Decision 1 a fost mai rapid și mai previzibil: Latența mediană a fost 325 ms față de 1.068 ms, iar cea mai lentă cerere a durat 1,0 s față de 101,6 s.
Încrederea lui Decision 1 a fost utilizabilă: ECE a fost 0,050 față de 0,124, iar ridicarea pragului la 0,9 a crescut acuratețea pe răspunsurile păstrate de la 84,4% la 95,6%. Încrederea auto-raportată a lui Flash-Lite a separat abia răspunsurile corecte de cele greșite.
Costul și scalarea depind de cum formulezi întrebările: Decision 1 a fost de 4,3x mai ieftin pe mesaje singulare, dar fiecare întrebare plătește pentru descrierile opțiunilor. Așadar, păstrează inputul total sub ~16K tokeni și păstrează descrierile opțiunilor scurte.
Aceste rezultate vin dintr-o singură sarcină, un singur set de date și un număr mic de rulări dintr-un notebook Colab. Le poți trata ca observații dintr-un demo, nu ca afirmații generale de performanță.
Întrebări frecvente
Care este diferența dintre Decisions API și un API generativ?⌄
Un API generativ își scrie răspunsul token cu token și facturează fiecare token de ieșire. Decisions API punctează un set fix de opțiuni într-un singur forward pass și întoarce o probabilitate pentru fiecare. Nu generează tokeni de ieșire, așa că plătești doar pentru intrare.
Este Gemini Decision 1 mai precis decât Gemini 3.5 Flash-Lite?⌄
Nu în testul nostru. Pe 180 de mesaje bancare, acuratețea a fost 84,4% pentru Decision 1 și 83,9% pentru Flash-Lite. Diferențele pe care le-am măsurat au fost la latență, calibrare și cost.
De ce Decision 1 folosește mai mulți tokeni de intrare decât Flash-Lite?⌄
Instrucțiunea fiecărei întrebări și descrierile opțiunilor se contorizează ca intrare. Cu 12 opțiuni descrise, asta a adăugat aproximativ 300 de tokeni pe întrebare în testul nostru. Descrierile scurte sau goale reduc acest lucru.
Rămâne latența plată pe măsură ce adaug mai multe întrebări?⌄
În rulările noastre, mediana a rămas sub 650 ms până la 50 de întrebări. La 100 de întrebări cu descrieri complete ale opțiunilor, cererea a ajuns la aproximativ 30K tokeni și a durat 48–59 s. Cu descrieri goale, aceleași 100 de întrebări au încăput în aproximativ 16K tokeni și au durat 1,6 s.
Ce tipuri de întrebări suportă Decisions API?⌄
Decisions API suportă trei tipuri de întrebări, inclusiv noul pentru verificări da/nu, choice pentru alegerea unei opțiuni din 2 până la 255 și score pentru notare pe un barem ordonat. Poți combina toate cele trei într-o singură cerere.
Analyze data smarter with Gemini in Google Sheets. Use AI-powered insights, formula suggestions, and automation to simplify spreadsheets and boost productivity.
Majoritatea aplicațiilor bazate pe LLM sunt pline de mici decizii: Ce unealtă ar trebui să apeleze agentul? Ce model ar trebui să preia această interogare? Încalcă acest mesaj o politică?
Astăzi, multe echipe răspund la aceste întrebări cerând unui model generativ să scrie răspunsul ca text, apoi analizând acel text pentru a lua o decizie.
Gemini Decisions API de la Google abordează altfel problema. Folosește modelul Gemini Decision 1 pentru a puncta un set fix de opțiuni într-un singur forward pass și întoarce o probabilitate pentru fiecare opțiune, cu zero tokeni de ieșire facturați.
În acest tutorial, vom rula aceeași sarcină de clasificare a intențiilor pe două configurații:
Le vom compara la acuratețe, latență, utilizare de tokeni, cost și calibrare, apoi vom împinge ambele de la 1 la 100 de întrebări într-o singură cerere.
La finalul acestui tutorial, vei ști cum să:
Apelezi Decisions API cu întrebări
choiceși să citești probabilitățile și scorurile de încredereConstruiești un baseline generativ cu Interactions API și un schelet JSON
Măsori latența, utilizarea de tokeni și costul pentru ambele abordări
Verifici dacă încrederea unui model poate fi de încredere, folosind un diagramă de fiabilitate și eroarea de calibrare așteptată (ECE)
Decizi când un model de decizie se potrivește aplicației tale mai bine decât unul generativ
Poți rula tot codul în acest Google Colab.
Modele de decizie vs. modele generative
Înainte să vedem cum funcționează fiecare, să definim cei doi termeni.
Iată un exemplu.
Un client scrie unei bănci: „Cardul meu încă n-a sosit. Când va veni?”
Dacă întrebi un model generativ „Ce vrea acest client?”, ți-ar putea răspunde:
„Clientul așteaptă un card nou și vrea să știe când va sosi.”
E un răspuns bun pentru un om. Dar dacă aplicația ta trebuie să direcționeze mesajul către echipa potrivită, codul tău trebuie acum să transforme acea propoziție într-o etichetă. Poți impune o etichetă cu un schelet JSON, dar modelul tot o scrie token cu token.
Însă, dacă întrebi un model de decizie același lucru, îi dai mai întâi opțiunile, precum
card_arrival,lost_or_stolen_cardșiexchange_rate. Îți întoarce o probabilitate pentru fiecare:Codul tău poate apoi acționa direct pe acea probabilitate, direcționând către echipa de carduri dacă
card_arrivaleste peste un prag și trimițând la un om dacă nu. Pe scurt:Model generativ
Model de decizie
Returnează
Text scris de el
O probabilitate pentru fiecare opțiune definită
Răspunsuri posibile
Deschise
Set fix
Bun pentru
Răspunsuri, rezumate, explicații și extragere
Rutare, selecție de unelte, verificări de politici și notare
În practică, multe aplicații folosesc un model generativ pentru ambele roluri. Asta vom testa în secțiunea următoare: dacă un model de decizie face partea de clasificare mai bine decât un model generativ.
Când folosești un model generativ ca clasificator, el scrie răspunsul token cu token. Pentru un răspuns JSON ca al nostru, ieșirea arată așa pe măsură ce este generată:
Fiecare token este un pas de decodare separat, iar fiecare token de ieșire este facturat. Dacă vrei un scor de încredere, modelul trebuie să scrie și acel număr. Acel număr este presupunerea modelului despre el însuși, nu o probabilitate măsurată din mecanismele sale interne.
Un model de decizie, însă, sare peste pasul de scriere. Îi dai opțiunile din start și punctează toate opțiunile față de input într-un singur forward pass. Rezultatul este o probabilitate pentru fiecare opțiune:
Asta schimbă trei lucruri pe care le poți măsura:
Compromisul este că poți pune doar întrebări cu set închis. Un model de decizie nu își poate explica răspunsul, nu poate extrage o valoare sau scrie text liber.
Demo: Construirea unui clasificator de intenții bancare
În acest demo, vom construi un clasificator de intenții bancare. Vom folosi splitul de test din Banking77, un set de date public cu mesaje de clienți etichetate cu 77 de intenții, și vom păstra 12 intenții ușor de confundat între ele:
card_arrivalșicard_delivery_estimatepending_card_payment,declined_card_paymentșicard_payment_fee_chargedpending_transfer,transfer_not_received_by_recipientșibalance_not_updated_after_bank_transferlost_or_stolen_card,card_not_working,exchange_rateșitop_up_failedIntențiile similare fac sarcina mai grea, ceea ce face scorurile de încredere mai interesante de studiat.
Vom rula clasificatorul cu ambele modele în două moduri:
Iată setările pe care le păstrăm la fel pentru ambele modeles:
Setare
Valoare folosită
De ce
Model de decizie
gemini-decision-1Modelul testat
Model generativ
gemini-3.5-flash-liteBaseline-ul generativ eficient ca cost folosit în comparația din anunțul de lansare
Temperatura Flash-Lite
0.0
Elimină zgomotul de eșantionare din baseline
Nivelul de „gândire” Flash-Lite
minimalPăstrează comparația la partea de decodare, nu de raționare
Format ieșire
Schelet JSON cu un
enumal celor 12 eticheteFlash-Lite poate întoarce doar o etichetă validă
Descrieri ale opțiunilor
O propoziție scurtă per intenție
Ambele modele văd aceleași definiții ale etichetelor
Apeluri de încălzire
2 per model
Exclude configurarea conexiunii din măsurători
Repetări (multe întrebări per cerere)
3 per setare
Raportăm mediana, nu o singură rulare
Notă: Acestea sunt setări de lucru pentru acest demo, nu setări optimizate pentru vreunul dintre modele.
Pasul 1: Cerințe și configurare
Ca să urmezi tutorialul, ai nevoie de:
O cheie de API Gemini de la Google AI Studio
Un notebook Colab (sau orice mediu Python 3)
google-genaiversiunea 3.2 sau mai nouăDecisions API are un nivel fără cost în Google AI Studio pentru prototipare, așa că îl poți încerca înainte să plătești. Eu am rulat acest demo în Colab, dar poți folosi orice mediu Python 3.
Să începem prin a instala pachetele:
Aici,
google-genaieste SDK-ul Python de la Google pentru Gemini API. Ne oferă metodeleclient.decisions.createșiclient.interactions.create, care trimit cereri către Decisions API și Interactions API. Folosimpandaspentru a încărca setul de date și a organiza rezultatele, iarmatplotlibpentru a desena figurile.În continuare, creăm clientul. Decisions API are nevoie de versiunea de API v1beta:
Aici,
genai.Client()citește cheia API dinGEMINI_API_KEYsetată la „secrets” în Colab sau ca variabilă de mediu, iarhttp_optionsîl indică spre API-ul v1beta, unde se află Decisions API.Apoi vom încărca setul de date Banking77 și vom defini cele 12 intenții. Fiecare intenție primește o descriere într-o propoziție pe care o vor vedea ambele modele:
Fragmentul de cod de mai sus descarcă splitul de test Banking77 ca fișier CSV și păstrează doar rândurile etichetate cu una dintre cele 12 intenții. Apoi eșantionează 15 mesaje per intenție cu un seed fix, astfel încât să obții același eșantion la fiecare rulare. Ultimul
.sample(frac=1)amestecă rândurile pentru a combina intențiile.Asta ne oferă 180 de mesaje, 15 per intenție.
Pasul 2: Clasifică cu Decisions API
O întrebare de tip
choiceprimește un dicționar care map-ează fiecare ID de opțiune la o descriere. Trimitem mesajul cainputși punem o singură întrebare, cu cheiaintent:Funcția
decide_intent()trimite un mesaj cainputși o întrebarechoicecu cele 12 intenții ca opțiuni. Cronometrăm apelul cutime.perf_counter(), apoi citim opțiunea de top, încrederea, toate probabilitățile opțiunilor și numărul de tokeni din răspuns.Fiecare răspuns conține trei câmpuri:
choice: Opțiunea cu cea mai mare probabilitateprobabilities: O probabilitate per opțiune, care însumează 1confidence: Probabilitatea estimată ca răspunsul de top să fie corectObiectul
usageraportează tokenii de intrare, iartotal_output_tokenseste mereu 0.Iată rezultatul pentru primul mesaj din eșantionul nostru:
Modelul a confundat două intenții similare, dar încrederea de 0,846 arată ceva incertitudine. Partea bună este că intenția corectă,
card_arrival, a venit pe locul al doilea cu aproape toată probabilitatea rămasă (aprox. 0,15). Toate celelalte opțiuni au fost aproape de zero.Pasul 3: Clasifică cu Flash-Lite
Pentru baseline-ul generativ, folosim ieșire structurată cu un
enumal acelorași 12 etichete, astfel încât Flash-Lite să poată întoarce doar o etichetă validă. Cerem și o încredere între 0 și 1, ceea ce este modul în care majoritatea aplicațiilor obțin un scor de încredere de la un model generativ:Funcția
generate_intent()construiește un prompt cu cele 12 intenții și descrierile lor. Apelează Flash-Lite curesponse_formatsetat la scheletul nostru JSON, astfel încât ieșirea trebuie să fie JSON valid cu una dintre cele 12 etichete. Temperatura este setată la0cu nivel de gândireminimalpentru a păstra răspunsul stabil și scurt. Apoi analizăminteraction.output_textcujson.loads()și citim numărătorile de tokeni dininteraction.usage.Am testat același mesaj ca la pasul anterior cu Flash-Lite și a făcut aceeași greșeală, cu o încredere mai mare:
Tokenii de „gândire” sunt 0, ceea ce confirmă că nivelul
minimala făcut ca Flash-Lite să scrie doar răspunsul. Flash-Lite a folosit mai puțini tokeni de intrare decât Decision 1 (277 vs 337) pentru că Decisions API contorizează descrierile opțiunilor din interiorul întrebării ca intrare.Pasul 4: Clasifică un mesaj per cerere
Acum, să trimitem toate cele 180 de mesaje la ambele modele, câte o cerere pe rând, după câte două apeluri de încălzire fiecare:
Acest buclă trimite fiecare mesaj la ambele funcții și salvează predicția, încrederea, latența și numărătorile de tokeni ca un rând. Apoi transformăm rândurile într-un DataFrame și adăugăm o coloană „correct” care marchează dacă fiecare predicție corespunde etichetei reale.
Iată rezultatele:
Metrică
Gemini Decision 1
Gemini 3.5 Flash-Lite
Acuratețe
84,4%
83,9%
Latență mediană
325 ms
1.068 ms
Latență p90
412 ms
6.483 ms
Cea mai lentă cerere
1,0 s
101,6 s
Cereri peste 5 s
0 din 180
33 din 180
Tokeni medii de intrare
339
279
Tokeni medii de ieșire
0
25
Iată trei lucruri pe care le-am învățat din aceste valori:
Notă: Timpii includ drumul prin rețea din Colab, așa că tratează diferența ca dependentă de configurare.
Pasul 5: Verifică calibrarea
Acuratețea ne spune cât de des un model are dreptate, dar calibrarea ne spune dacă încrederea lui are sens sau nu. Un model este bine calibrat când încrederea lui se potrivește cu acuratețea, adică, dacă spune 0,8 pe un grup de răspunsuri, aproximativ 80% dintre ele ar trebui să fie corecte.
Pentru a măsura asta, grupăm predicțiile în 10 intervale de încredere și comparăm încrederea medie a fiecărui interval cu acuratețea lui. Expected calibration error (ECE) este diferența medie, ponderată după câte predicții cad în fiecare interval. Mai mic este mai bine.
Funcția
ece()plasează fiecare predicție într-unul dintre cele 10 intervale după încredere (0–0,1, 0,1–0,2 etc.). Pentru fiecare interval, ia diferența dintre încrederea medie și acuratețe, o ponderizează cu ponderea predicțiilor din acel interval și adună rezultatele.Iată cum se compară cele două modele:
Metrică
Gemini Decision 1
Gemini 3.5 Flash-Lite
Acuratețe
84,4%
83,9%
Încredere medie
0,867
0,957
ECE
0,050
0,124
Încredere medie când e corect
0,901
0,966
Încredere medie când e greșit
0,686
0,912
Figura: Diagrame de fiabilitate pentru ambele modele
Încrederea lui Decision 1 este aproape de acuratețea lui, cu un ECE de 0,050. Este, de asemenea, evident mai mică atunci când modelul greșește (0,686) decât atunci când are dreptate (0,901).
Flash-Lite este prea încrezător. Raportează 0,957 în medie, deși are dreptate 83,9% din timp. A folosit doar 9 valori distincte de încredere pe 180 de răspunsuri, iar 158 dintre ele au fost 0,95 sau mai mari. Chiar și răspunsurile greșite au avut în medie 0,912. Numărul arată ca o probabilitate, dar este estimarea modelului, scrisă ca text.
Calibrarea contează când acționezi pe baza scorului. Un tipar comun este să accepți răspunsuri peste un prag de încredere și să trimiți restul către un model fallback sau un om:
Prag
Decision 1: pondere păstrată
Decision 1: acuratețe pe cele păstrate
Flash-Lite: pondere păstrată
Flash-Lite: acuratețe pe cele păstrate
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%
Cu Decision 1, un prag mai înalt funcționează cum te-ai aștepta. La 0,9, păstrează 63% dintre mesaje la 95,6% acuratețe. Cu Flash-Lite, pragul ajută abia, pentru că majoritatea răspunsurilor greșite au și ele încredere mare. Documentația oficială recomandă alegerea unui prag din exemple etichetate din traficul tău.
Pasul 6: Clasifică 100 de mesaje într-o singură cerere
Decisions API poate răspunde la până la 1.000 de întrebări despre un input comun într-o singură cerere. Pentru a testa asta, punem N mesaje de la clienți într-un singur input și punem o întrebare per mesaj.
Pentru Decision 1, asta înseamnă N întrebări
choicecu cheile de lam1lamN:Aici, funcția
build_batch()numerotează primele N mesaje și le unește într-un singur input comun. Apoidecide_batch()creează o întrebarechoiceper mesaj, cu cheile de lam1lamN, le trimite pe toate într-o singură cerere și citește câte un răspuns per cheie.Pentru Flash-Lite, trimitem același input comun cu un schelet JSON care are N câmpuri, fiecare limitat la 12 etichete. Fiecare N folosește aceleași mesaje pentru ambele modele, iar fiecare setare rulează de trei ori.
Întrebări per cerere
Decision 1: latență mediană
Flash-Lite: latență mediană
Decision 1: tokeni intrare
Flash-Lite: tokeni intrare / ieșire
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
Eșuat
15.100
Eșuat
100
59.095 ms
Eșuat
30.309
Eșuat
Până la 25 de întrebări, latența mediană a lui Decision 1 a rămas sub 550 ms. Mediana lui Flash-Lite a crescut cu N, de la sub 1 s la 1–5 întrebări la 2,75 s la 25, pentru că trebuie să scrie fiecare răspuns ca tokeni de ieșire. Chiar și la 50 de întrebări, mediana lui Decision 1 a fost 592 ms, deși una dintre cele trei rulări a durat 70 s.
Iată două puncte-cheie de analizat:
Pasul 7: Optimizează cererile
Acum apare o întrebare evidentă: putem remedia încetinirea și eșecurile? Pentru Decision 1, folosim descrieri goale ale opțiunilor (""). Pentru Flash-Lite, cerem o singură listă de N etichete în loc de N câmpuri separate:
Iată cum a mers Decision 1 cu descrieri goale:
Întrebări per cerere
Latență mediană
Acuratețe
Tokeni de intrare
25
357 ms
84,0%
3.995
50
649 ms
78,0%
7.950
100
1.603 ms
83,0%
16.009
Renunțarea la descrieri a înjumătățit aproximativ tokenii de intrare. La 100 de întrebări, cererea a coborât la ~16K tokeni, iar mediana latenței a scăzut de la 59 s la 1,6 s. Acuratețea a scăzut puțin la 25 și 50 de întrebări, așa că descrierile scurte sunt un compromis mai bun decât lipsa lor, mai ales pentru intenții similare.
Schema de listă nu a ajutat modelul Flash-Lite. A funcționat la 25 de întrebări, dar tot a eșuat la 50 și 100.
Pasul 8: Compară costul
În final, calculăm costul din numărătorile de tokeni pe care le întoarce fiecare API, folosind prețuri din nivelul plătit:
Model
Preț intrare per 1M tokeni
Preț ieșire per 1M tokeni
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (inclusiv tokeni de gândire)
Funcția
cost_per_request()înmulțește fiecare număr de tokeni cu prețul per 1M tokeni. Pentru Decision 1, contează doar tokenii de intrare. Pentru Flash-Lite, tokenii de „gândire” sunt facturați la prețul ieșirii, deci îi adăugăm la tokenii de ieșire.Iată costul per 1.000 de cereri pentru fiecare configurare:
Configurare
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 mesaj per cerere
$0,034
$0,147
4,3x
5 întrebări per cerere
$0,155
$0,271
1,7x
10 întrebări per cerere
$0,306
$0,459
1,5x
25 întrebări per cerere
$0,757
$1,088
1,4x
25 întrebări, configurații optimizate (Pasul 7)
$0,400
$0,831
2,1x
50 întrebări per cerere
$1,510
Eșuat
n/a
100 întrebări, descrieri goale
$1,601
Eșuat
n/a
Pe mesaje singulare, Decision 1 a fost de 4,3x mai ieftin, dar diferența se micșorează pe măsură ce grupezi mai multe întrebări într-o singură cerere. Inputul comun este facturat o dată în ambele API-uri. Dar fiecare întrebare Decision 1 poartă propria instrucțiune și toate cele 12 descrieri ale opțiunilor, în timp ce Flash-Lite vede lista etichetelor o singură dată și plătește pentru o ieșire scurtă per răspuns. La 25 de întrebări, Decision 1 a folosit 7.570 tokeni de intrare față de 710 tokeni de intrare și 350 de ieșire pentru Flash-Lite.
Notă: Decisions API nu suportă context caching sau Batch API. Dacă trimiți același input în mai multe cereri, este facturat integral de fiecare dată. Așadar, când ai multe întrebări despre același input, pune-le într-o singură cerere, nu împrăștiate pe mai multe apeluri.
Când să folosești fiecare abordare
Pe baza rulărilor de mai sus, un model de decizie se potrivește mai bine când:
Un model generativ tot se potrivește mai bine când:
Folosește Decisions API când ai nevoie de
Folosește Interactions API când ai nevoie de
O probabilitate da/nu, o opțiune dintr-un set fix sau un scor pe o scală fixă
Text generat, rezumate sau explicații
Probabilități calibrate pe care le poți pragui
Valori sau obiecte extrase care urmează propriul tău schelet JSON
Multe verificări independente pe același input într-un apel
Apeluri de unelte cu argumente
Latență mică și cost zero pentru tokenii de ieșire
Raționament în mai mulți pași
Gânduri de final
În acest tutorial, am construit un clasificator de intenții bancare cu Gemini Decision 1 și Gemini 3.5 Flash-Lite, apoi am calculat acuratețea, latența, calibrarea și costul pentru a compara cele două modele. Iată patru concluzii din tutorial:
Aceste rezultate vin dintr-o singură sarcină, un singur set de date și un număr mic de rulări dintr-un notebook Colab. Le poți trata ca observații dintr-un demo, nu ca afirmații generale de performanță.