Vai al contenuto principale

Gemini Decisions API: test del nuovo modello decisionale di Google su latenza e costo

Scopri come Gemini Decision 1 valuta opzioni fisse senza generare testo, crea un classificatore di intenti bancari con la Decisions API e confrontalo con Gemini 3.5 Flash-Lite per accuratezza, latenza, calibrazione e costo.
· 15 min leggi

Scopri con l'IA

La maggior parte delle app basate su LLM è piena di piccole decisioni: Quale strumento dovrebbe chiamare l’agente? Quale modello dovrebbe gestire questa query? Questo messaggio viola una policy?

Oggi, molti team rispondono a queste domande chiedendo a un modello generativo di scrivere la risposta come testo, per poi analizzare quel testo per prendere una decisione.

La Gemini Decisions API di Google adotta un approccio diverso. Usa il modello Gemini Decision 1 per valutare un set fisso di opzioni in un singolo forward pass e restituisce una probabilità per ciascuna opzione, con zero token di output fatturati.

In questo tutorial eseguiremo lo stesso compito di classificazione degli intenti su due impostazioni:

  • Gemini Decision 1 tramite la Decisions API
  • Gemini 3.5 Flash-Lite tramite la Interactions API, usando output JSON strutturato

Li confronteremo in termini di accuratezza, latenza, utilizzo di token, costo e calibrazione, e poi spingeremo entrambi da 1 a 100 domande in una singola richiesta.

Alla fine di questo tutorial saprai come:

  • Chiamare la Decisions API con domande choice e leggere le sue probabilità e i punteggi di confidenza

  • Costruire un baseline generativo con la Interactions API e uno schema JSON

  • Misurare latenza, uso dei token e costo per entrambi gli approcci

  • Verificare se la confidenza di un modello è affidabile, usando un reliability diagram e l’expected calibration error (ECE)

  • Decidere quando un modello decisionale si adatta meglio alla tua app rispetto a uno generativo

Puoi eseguire il codice completo in questo Google Colab.

Modelli decisionali vs. modelli generativi

Prima di vedere come funziona ciascuno, definiamo i due termini.

  • Modello generativo: Questo modello produce nuovo contenuto. Gli dai un prompt e scrive una risposta un token alla volta. Quella risposta può essere qualsiasi cosa: una risposta, un riassunto, del codice o un’etichetta. Gemini 3.5 Flash-Lite, come la maggior parte degli LLM che usiamo nelle app di chat, è un modello generativo.
  • Modello decisionale: Un modello decisionale sceglie tra le opzioni che definisci tu. Gli fornisci un input e una lista fissa di possibili risposte e lui ti dice la probabilità di ciascuna opzione senza scrivere una sola riga di testo. Gemini Decision 1 è un modello decisionale.

Ecco un esempio. 

Un cliente scrive a una banca: "La mia carta non è ancora arrivata. Quando arriverà?"

Se chiedi a un modello generativo, "Cosa vuole questo cliente?", potrebbe rispondere:

“Il cliente sta aspettando una nuova carta e vuole sapere quando arriverà.”

È una buona risposta per un essere umano. Ma se la tua app deve inoltrare il messaggio al team giusto, ora il tuo codice deve trasformare quella frase in un’etichetta. Puoi forzare un’etichetta con uno schema JSON, ma il modello la scrive comunque token per token.

Se però poni la stessa domanda a un modello decisionale, prima gli dai le opzioni, ad esempio card_arrival, lost_or_stolen_card ed exchange_rate. Restituisce una probabilità per ciascuna:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Il tuo codice può quindi agire direttamente su quella probabilità, inoltrando al team carte se card_arrival è sopra una soglia e inviandolo a un umano in caso contrario. In breve:

 

Modello generativo

Modello decisionale

Restituisce

Testo che scrive

Una probabilità per ciascuna opzione che definisci

Possibili risposte

Aperte

Set fisso

Utile per

Risposte, riassunti, spiegazioni ed estrazione

Instradamento, selezione strumenti, controlli di policy e valutazione

Nella pratica, molte app usano un modello generativo per entrambi i lavori. È ciò che testeremo nella prossima sezione: se un modello decisionale svolge la parte di classificazione meglio di un modello generativo.

Quando usi un modello generativo come classificatore, scrive la risposta un token alla volta. Per una risposta JSON come la nostra, l’output appare così durante la generazione:

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

Ogni token è uno step di decodifica separato e ogni token di output è fatturato. Se vuoi un punteggio di confidenza, il modello deve scrivere anche quel numero. Quel numero è la stima del modello su se stesso, non una probabilità misurata dai suoi interni.

Un modello decisionale, invece, salta questa fase di scrittura. Fornisci in anticipo le opzioni e lui le valuta tutte rispetto all’input in un unico forward pass. Il risultato è una probabilità per ogni opzione:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Questo cambia tre aspetti che puoi misurare:

  • Latenza: Non c’è un loop di decodifica, quindi la latenza non dovrebbe crescere con la lunghezza della risposta.
  • Costo: Non ci sono token di output da fatturare. Paghi solo i token di input, che includono il testo della domanda e le descrizioni delle opzioni.
  • Confidenza: La confidenza deriva dalle probabilità stesse, quindi dovrebbe rispecchiare la frequenza con cui il modello ha ragione.

Il compromesso è che puoi porre solo domande a set chiuso. Un modello decisionale non può spiegare la sua risposta, estrarre un valore o scrivere testo libero.

Demo: costruire un classificatore di intenti bancari

In questa demo costruiremo un classificatore di intenti bancari. Useremo lo split di test di Banking77, un dataset pubblico di messaggi dei clienti etichettati con 77 intenti, e terremo 12 intenti facili da confondere tra loro:

  • card_arrival e card_delivery_estimate

  • pending_card_payment, declined_card_payment e card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient e balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate e top_up_failed

Intenti simili rendono il compito più difficile, il che rende più interessanti da studiare i punteggi di confidenza.

Eseguiremo il classificatore con entrambi i modelli in due modi:

  • Un messaggio per richiesta: 180 messaggi (15 per intento), inviati a ciascun modello uno alla volta.
  • Molte domande per richiesta: N messaggi inseriti in un unico input condiviso, con una domanda per messaggio, per N = 1, 5, 10, 25, 50 e 100.

Ecco le impostazioni che manteniamo uguali per entrambi i modelli:

Impostazione

Valore usato

Perché 

Modello decisionale

gemini-decision-1

Il modello in esame

Modello generativo

gemini-3.5-flash-lite

Il baseline generativo economico usato nel confronto del post di lancio

Temperatura di Flash-Lite

0.0

Rimuove il rumore di campionamento dal baseline

Livello di thinking di Flash-Lite

minimal

Mantiene il confronto sulla decodifica, non sul ragionamento

Formato di output

Schema JSON con un enum delle 12 etichette

Flash-Lite può restituire solo un’etichetta valida

Descrizioni delle opzioni

Una frase breve per intento

Entrambi i modelli vedono le stesse definizioni delle etichette

Chiamate di warmup

2 per modello

Tiene la configurazione della connessione fuori dalle misure

Ripetizioni (molte domande per richiesta)

3 per impostazione

Riportiamo la mediana, non una singola esecuzione

Nota: Queste sono impostazioni operative per questa demo, non impostazioni ottimizzate per nessuno dei due modelli.

Passo 1: Prerequisiti e setup

Per seguire il tutorial ti servono:

  • Una chiave API Gemini da Google AI Studio

  • Un notebook Colab (o qualsiasi ambiente Python 3)

  • google-genai versione 3.2 o successiva

La Decisions API ha un livello senza costi in Google AI Studio per il prototyping, così puoi provarla prima di pagare. Ho eseguito questa demo in Colab, ma sentiti libero di usare qualsiasi ambiente Python 3. 

Iniziamo installando i pacchetti:

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

Qui, google-genai è l’SDK Python di Google per la Gemini API. Ci fornisce i metodi client.decisions.create e client.interactions.create, che inviano richieste alla Decisions API e alla Interactions API. Usiamo pandas per caricare il dataset e organizzare i risultati, e matplotlib per disegnare i grafici.

Poi creiamo il client. La Decisions API richiede la versione 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"

Qui, genai.Client() legge la chiave API da GEMINI_API_KEY impostata tra i secrets in Colab o come variabile d’ambiente, e http_options lo punta alla API v1beta, dove risiede la Decisions API. 

Quindi carichiamo il dataset Banking77 e definiamo i nostri 12 intenti. Ogni intento ottiene una descrizione in una frase che verrà vista da entrambi i modelli:

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

Lo snippet sopra scarica lo split di test di Banking77 come file CSV e mantiene solo le righe etichettate con uno dei nostri 12 intenti. Quindi campiona 15 messaggi per intento con un seed fisso, così otterrai lo stesso campione a ogni esecuzione. Il .sample(frac=1) finale mescola le righe in modo che gli intenti siano mischiati.

Questo ci dà 180 messaggi, 15 per intento.

Passo 2: Classificare con la Decisions API

Una domanda choice accetta un dizionario che mappa ciascun ID opzione a una descrizione. Passiamo il messaggio come input e poniamo una domanda, con chiave 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,
    }

La funzione decide_intent() invia un messaggio come input e una domanda choice con i nostri 12 intenti come opzioni. Misuriamo il tempo con time.perf_counter(), poi leggiamo la scelta migliore, la confidenza, tutte le probabilità delle opzioni e i conteggi dei token dalla risposta.

Ogni risposta contiene tre campi:

  • choice: L’opzione con la probabilità più alta

  • probabilities: Una probabilità per opzione, che somma a 1

  • confidence: La probabilità stimata che la risposta migliore sia corretta

L’oggetto usage riporta i token di input e total_output_tokens è sempre 0.

Ecco il risultato per il primo messaggio del nostro campione:

Il modello ha confuso due intenti simili, ma la sua confidenza di 0,846 mostra una certa incertezza. La parte positiva è che l’intento corretto, card_arrival, è arrivato secondo con quasi tutta la probabilità rimanente (circa 0,15). Tutte le altre opzioni erano vicine a zero.

Passo 3: Classificare con Flash-Lite

Per il baseline generativo, usiamo un output strutturato con un enum delle stesse 12 etichette, così Flash-Lite può restituire solo un’etichetta valida. Chiediamo anche una confidenza tra 0 e 1, che è come la maggior parte delle app ottiene un punteggio di confidenza da un modello generativo:

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

La funzione generate_intent() costruisce un prompt con i 12 intenti e le loro descrizioni. Chiama Flash-Lite con response_format impostato sul nostro schema JSON, così l’output deve essere JSON valido con una delle 12 etichette. La temperatura è impostata a 0 con livello di thinking minimal per mantenere la risposta stabile e breve. Quindi analizziamo interaction.output_text con json.loads() e leggiamo i conteggi dei token da interaction.usage.

Ho testato lo stesso messaggio del passo precedente con Flash-Lite, e ha commesso lo stesso errore con maggiore confidenza:

I thinking token sono 0, il che conferma che il livello minimal ha mantenuto Flash-Lite al solo writing della risposta. Flash-Lite ha usato meno token di input rispetto a Decision 1 (277 vs 337) perché la Decisions API conta come input le descrizioni delle opzioni all’interno della domanda.

Passo 4: Classificare un messaggio per richiesta

Ora, inviamo tutti i 180 messaggi a entrambi i modelli, una richiesta alla volta, dopo due chiamate di warmup ciascuno:

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

Questo loop invia ogni messaggio a entrambe le funzioni e salva predizione, confidenza, latenza e conteggi dei token come una riga. Poi trasformiamo le righe in un DataFrame e aggiungiamo una colonna correct che indica se ogni predizione corrisponde all’etichetta vera.

Ecco i risultati:

Metrica

Gemini Decision 1

Gemini 3.5 Flash-Lite

Accuratezza

84,4%

83,9%

Latenza mediana

325 ms

1.068 ms

Latenza p90

412 ms

6.483 ms

Richiesta più lenta

1,0 s

101,6 s

Richieste oltre 5 s

0 su 180

33 su 180

Token medi di input

339

279

Token medi di output

0

25

Ecco tre cose che abbiamo imparato da queste metriche:

  • Accuratezza: Entrambi i modelli sono stati circa ugualmente accurati.
  • Latenza: Decision 1 è stato circa 3 volte più veloce in mediana e molto più consistente, mentre Flash-Lite ha avuto una longa coda di richieste lente.
  • Token: Decision 1 ha usato più token di input perché le descrizioni delle opzioni contano come input, ma non ha generato token di output.

Nota: Le nostre misure includono il round-trip di rete da Colab, quindi considera quel divario come dipendente dall’ambiente.

Passo 5: Verificare la calibrazione

L’accuratezza ci dice quanto spesso un modello ha ragione, ma la calibrazione ci dice se la sua confidenza significa qualcosa o no. Un modello è ben calibrato quando la sua confidenza corrisponde alla sua accuratezza, cioè, se dice 0,8 su un gruppo di risposte, circa l’80% dovrebbe essere corretto.

Per misurarlo, raggruppiamo le predizioni in 10 bin di confidenza e confrontiamo la confidenza media di ciascun bin con la sua accuratezza. L’expected calibration error (ECE) è il divario medio, pesato per quante predizioni rientrano in ciascun bin. Più basso è, meglio è.

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

La funzione ece() colloca ogni predizione in uno di 10 bin in base alla sua confidenza (0–0,1, 0,1–0,2, e così via). Per ogni bin, prende il divario tra confidenza media e accuratezza, lo pesa per la quota di predizioni in quel bin e somma i risultati.

Ecco come si confrontano i due modelli:

Metrica

Gemini Decision 1

Gemini 3.5 Flash-Lite

Accuratezza

84,4%

83,9%

Confidenza media

0,867

0,957

ECE

0,050

0,124

Confidenza media quando corretto

0,901

0,966

Confidenza media quando sbagliato

0,686

0,912

Figura: Reliability diagram per entrambi i modelli

La confidenza di Decision 1 è vicina alla sua accuratezza, con un ECE di 0,050. È anche chiaramente più bassa quando il modello sbaglia (0,686) rispetto a quando ha ragione (0,901).

Flash-Lite è troppo sicuro di sé. Riporta in media 0,957 pur avendo ragione l’83,9% delle volte. Ha usato solo 9 valori distinti di confidenza su 180 risposte, e 158 di queste erano 0,95 o superiori. Anche le risposte sbagliate avevano in media 0,912. Il numero sembra una probabilità, ma è la stima del modello scritta come testo.

La calibrazione conta quando agisci sul punteggio. Uno schema comune è accettare le risposte sopra una soglia di confidenza e inviare il resto a un modello di fallback o a un umano:

Soglia

Decision 1: quota mantenuta

Decision 1: accuratezza sui mantenuti

Flash-Lite: quota mantenuta

Flash-Lite: accuratezza sui mantenuti

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%

Con Decision 1, una soglia più alta funziona come atteso. A 0,9, mantiene il 63% dei messaggi con un’accuratezza del 95,6%. Con Flash-Lite, la soglia aiuta poco, perché molte delle sue risposte sbagliate hanno comunque alta confidenza. La documentazione ufficiale consiglia di scegliere una soglia a partire da esempi etichettati del tuo traffico.

Passo 6: Classificare 100 messaggi in una richiesta

La Decisions API può rispondere fino a 1.000 domande su un input condiviso in una singola richiesta. Per testarlo, mettiamo N messaggi dei clienti in un input e poniamo una domanda per messaggio.

Per Decision 1, significa N domande choice con chiavi da m1 a 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

Qui, la funzione build_batch() numera i primi N messaggi e li unisce in un input condiviso. Quindi decide_batch() crea una domanda choice per messaggio, con chiavi da m1 a mN, le invia tutte in una singola richiesta e legge una risposta per chiave.

Per Flash-Lite, inviamo lo stesso input condiviso con uno schema JSON che ha N campi, ciascuno limitato a 12 etichette. Ogni N usa gli stessi messaggi per entrambi i modelli e ogni impostazione viene eseguita tre volte.

Domande per richiesta

Decision 1: latenza mediana

Flash-Lite: latenza mediana

1

318 ms

888 ms

5

353 ms

858 ms

10

398 ms

1.063 ms

25

546 ms

2.753 ms

50

592 ms

Failed

100

59.095 ms

Failed

Fino a 25 domande, la latenza mediana di Decision 1 è rimasta sotto i 550 ms. La mediana di Flash-Lite è cresciuta con N, da meno di 1 s con 1–5 domande a 2,75 s con 25, perché deve scrivere ogni risposta come token di output. Anche con 50 domande, la mediana di Decision 1 era 592 ms, sebbene una delle tre esecuzioni abbia impiegato 70 s.

Ecco due punti chiave su cui riflettere:

  • Flash-Lite è fallito a 50 e 100 domande: Le righe "Failed" nella tabella sopra sono tutte lo stesso errore 400. Indica che lo schema "ha troppi stati per il serving". Uno schema con 50 o più campi, ciascuno limitato a 12 etichette, supera ciò che l’API accetta.
  • Decision 1 è rallentato a 100 domande: Ogni domanda ripete tutte le 12 descrizioni delle opzioni, circa 300 token per domanda, quindi la richiesta ha raggiunto 30.309 token, mentre l’affermazione di latenza costante di Google copre contesti fino a 16K token.

Passo 7: Alleggerire le richieste

Ora sorge una domanda ovvia: possiamo correggere il rallentamento e i fallimenti? Per Decision 1, usiamo descrizioni delle opzioni vuote (""). Per Flash-Lite, chiediamo un’unica lista di N etichette invece di N campi separati:

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

Ecco come è andato Decision 1 con descrizioni vuote:

Domande per richiesta

Latenza mediana

Accuratezza

Token di input

25

357 ms

84,0%

3.995

50

649 ms

78,0%

7.950

100

1.603 ms

83,0%

16.009

Rimuovere le descrizioni ha grosso modo dimezzato i token di input. Con 100 domande, la richiesta è scesa a circa 16K token e la latenza mediana è calata da 59 s a 1,6 s. L’accuratezza è scesa un po’ a 25 e 50 domande, quindi descrizioni brevi sono un miglior compromesso rispetto a nessuna, soprattutto per intenti simili.

Lo schema a lista non ha aiutato il modello Flash-Lite. Ha funzionato a 25 domande, ma è comunque fallito a 50 e 100.

Passo 8: Confrontare i costi

Infine, calcoliamo il costo a partire dai conteggi dei token restituiti da ciascuna API, usando i prezzi del livello a pagamento:

Modello

Prezzo input per 1M token

Prezzo output per 1M token

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (inclusi i thinking token)

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

La funzione cost_per_request() moltiplica ciascun conteggio di token per il suo prezzo per 1M di token. Per Decision 1 contano solo i token di input. Per Flash-Lite, i thinking token sono fatturati al prezzo di output, quindi li sommiamo ai token di output.

Ecco il costo per 1.000 richieste per ciascuna configurazione:

Setup

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1 messaggio per richiesta

$0,034

$0,147

4,3x

5 domande per richiesta

$0,155

$0,271

1,7x

10 domande per richiesta

$0,306

$0,459

1,5x

25 domande per richiesta

$0,757

$1,088

1,4x

25 domande, setup alleggeriti (Passo 7)

$0,400

$0,831

2,1x

50 domande per richiesta

$1,510

Failed

n/d

100 domande, descrizioni vuote

$1,601

Failed

n/d

Su singoli messaggi, Decision 1 è stato 4,3 volte più economico, ma il divario si riduce man mano che accorpi più domande in una richiesta. L’input condiviso è fatturato una volta in entrambe le API. Ma ogni domanda di Decision 1 porta le proprie istruzioni e tutte le 12 descrizioni delle opzioni, mentre Flash-Lite vede la lista delle etichette una sola volta e paga per un breve output per risposta. Con 25 domande, Decision 1 ha usato 7.570 token di input contro i 710 di input e 350 di output di Flash-Lite.

Nota: La Decisions API non supporta il caching del contesto né la Batch API. Se invii lo stesso input in più richieste, viene fatturato per intero ogni volta. Quindi, quando hai molte domande sullo stesso input, ponile in una sola richiesta anziché distribuirle in più chiamate.

Quando usare ciascun approccio

In base alle esecuzioni sopra, un modello decisionale è più adatto quando:

  • La risposta proviene da un set fisso di opzioni, come intenti, rotte, strumenti o etichette di policy
  • La decisione si trova nel percorso della richiesta, dove ogni utente aspetta
  • Vuoi agire sulla confidenza, ad esempio inviando i casi poco chiari a un fallback o a un umano
  • Devi porre molte domande indipendenti sullo stesso input in una richiesta

Un modello generativo è invece più adatto quando:

  • Ti serve una spiegazione, un valore estratto o qualsiasi testo libero
  • Il set di possibili risposte è aperto o cambia per richiesta
  • Hai già effettuato una chiamata generativa su quell’input e puoi aggiungervi la classificazione

Usa la Decisions API quando ti serve

Usa la Interactions API quando ti serve

Una probabilità sì/no, un’opzione da un set fisso o una valutazione su una scala fissa

Testo generato, riassunti o spiegazioni

Probabilità calibrate che puoi sogliare

Valori o oggetti estratti che seguono il tuo schema JSON

Molti controlli indipendenti sullo stesso input in una chiamata

Chiamate a strumenti con argomenti

Bassa latenza e costo zero per i token di output

Ragionamento multi-step

Considerazioni finali

In questo tutorial, abbiamo costruito un classificatore di intenti bancari con Gemini Decision 1 e Gemini 3.5 Flash-Lite, quindi abbiamo calcolato accuratezza, latenza, calibrazione e costo per confrontare i due modelli. Ecco quattro punti chiave:

  • Accuratezza in parità: 84,4% per Decision 1 e 83,9% per Flash-Lite, con lo stesso verdetto su 163 dei 180 messaggi.
  • Decision 1 è stato più veloce e più prevedibile: la sua latenza mediana è stata 325 ms contro 1.068 ms e la sua richiesta più lenta ha impiegato 1,0 s contro 101,6 s.
  • La confidenza di Decision 1 era utilizzabile: il suo ECE è stato 0,050 contro 0,124, e alzare la soglia a 0,9 ha portato l’accuratezza delle risposte mantenute da 84,4% a 95,6%. La confidenza auto-riportata di Flash-Lite separava a malapena le risposte giuste da quelle sbagliate.
  • Costo e scaling dipendono da come scrivi le domande: Decision 1 è stato 4,3 volte più economico sui messaggi singoli, ma ogni domanda paga le sue descrizioni delle opzioni. Quindi, mantieni il totale di input sotto circa 16K token e tieni brevi le descrizioni delle opzioni.

Questi risultati provengono da un singolo task, un dataset e un numero ridotto di esecuzioni da un notebook Colab. Considerali come osservazioni da una demo più che come affermazioni generali di performance. 

Aashi Dutt

Autore

Aashi Dutt

Sono una Google Developers Expert in ML (Gen AI), una Kaggle 3x Expert e una Women Techmakers Ambassador con oltre 3 anni di esperienza nel tech. Ho co-fondato una startup health-tech nel 2020 e sto conseguendo un master in informatica al Georgia Tech, con specializzazione in machine learning.

FAQs

Qual è la differenza tra la Decisions API e un’API generativa?

Un’API generativa scrive la sua risposta token per token e fattura ogni token di output. La Decisions API valuta un set fisso di opzioni in un unico forward pass e restituisce una probabilità per ciascuna. Non genera token di output, quindi paghi solo l’input.

Gemini Decision 1 è più accurato di Gemini 3.5 Flash-Lite?

Non nel nostro test. Su 180 messaggi bancari, l’accuratezza è stata 84,4% per Decision 1 e 83,9% per Flash-Lite. Le differenze che abbiamo misurato riguardavano latenza, calibrazione e costo.

Perché Decision 1 usa più token di input rispetto a Flash-Lite?

Le istruzioni di ciascuna domanda e le descrizioni delle opzioni contano come input. Con 12 opzioni descritte, ciò ha aggiunto circa 300 token per domanda nel nostro test. Descrizioni brevi o vuote lo riducono.

La latenza resta piatta man mano che aggiungo domande?

Nelle nostre esecuzioni, la mediana è rimasta sotto i 650 ms fino a 50 domande. A 100 domande con descrizioni complete delle opzioni, la richiesta ha raggiunto circa 30K token e ha impiegato 48–59 s. Con descrizioni vuote, le stesse 100 domande rientrano in circa 16K token e hanno impiegato 1,6 s.

Quali tipi di domande supporta la Decisions API?

La Decisions API supporta tre tipi di domande, tra cui noul per i controlli sì/no, choice per scegliere una opzione da 2 a 255, e score per valutare su una rubrica ordinata. Puoi mescolare tutti e tre in una richiesta.

Argomenti

Correlato