Gemini Decisions API : test du nouveau modèle de décision de Google sur la latence et le coût
Découvrez comment Gemini Decision 1 évalue des options fixes sans générer de texte, créez un classifieur d'intentions bancaires avec la Decisions API et comparez-le à Gemini 3.5 Flash-Lite en exactitude, latence, calibration et coût.
La plupart des applications basées sur des LLM sont truffées de micro-décisions : quel outil l'agent doit-il appeler ? Quel modèle doit traiter cette requête ? Ce message enfreint-il une politique ?
Aujourd'hui, beaucoup d'équipes posent ces questions à un modèle génératif qui rend une réponse en texte, puis analysent ce texte pour prendre la décision.
La Gemini Decisions API de Google adopte une autre approche. Elle utilise le modèle Gemini Decision 1 pour noter un ensemble fixe d'options en un seul passage et renvoie une probabilité par option, sans aucun jeton de sortie facturé.
Dans ce tutoriel, nous allons exécuter la même tâche de classification d'intention sur deux configurations :
Gemini Decision 1 via la Decisions API
Gemini 3.5 Flash-Lite via l'Interactions API, avec une sortie JSON structurée
Nous les comparerons sur l'exactitude, la latence, l'utilisation de jetons, le coût et la calibration, puis nous passerons de 1 à 100 questions dans une seule requête.
Au terme de ce tutoriel, vous saurez :
Appeler la Decisions API avec des questions choice et lire ses probabilités et scores de confiance
Construire une base générative avec l'Interactions API et un schéma JSON
Mesurer la latence, l'utilisation de jetons et le coût pour les deux approches
Vérifier la fiabilité d'un score de confiance à l'aide d'un diagramme de fiabilité et de l'erreur de calibration attendue (ECE)
Décider quand un modèle de décision convient mieux à votre application qu'un modèle génératif
Vous pouvez exécuter l'intégralité du code dans ce Google Colab.
Modèles de décision vs modèles génératifs
Avant d'entrer dans le détail de leur fonctionnement, définissons les deux termes.
Modèle génératif : ce modèle produit du contenu. Vous lui donnez une instruction, et il écrit une réponse jeton par jeton. Cette réponse peut être une réponse, un résumé, du code ou une étiquette. Gemini 3.5 Flash-Lite, comme la plupart des LLM utilisés dans des applications de chat, est un modèle génératif.
Modèle de décision : un modèle de décision choisit parmi les options que vous définissez. Vous lui fournissez une entrée et une liste fixe de réponses possibles, et il indique la probabilité de chaque option sans écrire la moindre ligne de texte. Gemini Decision 1 est un modèle de décision.
Voici un exemple.
Un client écrit à une banque : "Ma carte n'est pas encore arrivée. Quand la recevrai-je ?"
Si vous demandez à un modèle génératif « Que veut ce client ? », il pourrait répondre :
« Le client attend une nouvelle carte et veut savoir quand elle arrivera. »
C'est une bonne réponse pour un humain. Mais si votre application doit router le message vers la bonne équipe, votre code doit maintenant convertir cette phrase en étiquette. Vous pouvez imposer une étiquette avec un schéma JSON, mais le modèle l'écrit toujours jeton par jeton.
En revanche, si vous posez la même question à un modèle de décision, vous fournissez d'abord les options, par exemple card_arrival, lost_or_stolen_card et exchange_rate. Il renvoie une probabilité pour chacune :
card_arrival 0.91
lost_or_stolen_card 0.06
exchange_rate 0.03Propulsé par
Votre code peut alors agir directement sur cette probabilité : router vers l'équipe carte si card_arrival dépasse un seuil, et envoyer à un humain sinon. En bref :
Modèle génératif
Modèle de décision
Renvoie
Un texte qu'il écrit
Une probabilité pour chaque option définie
Réponses possibles
Ouvertes
Ensemble fixe
Adapté à
Réponses, résumés, explications et extraction
Routage, sélection d'outils, contrôles de politiques et évaluation
En pratique, beaucoup d'applications utilisent un modèle génératif pour les deux rôles. C'est ce que nous allons tester dans la section suivante : un modèle de décision fait-il mieux la partie classification qu'un modèle génératif ?
Quand vous utilisez un modèle génératif comme classifieur, il écrit la réponse jeton par jeton. Pour une réponse JSON comme la nôtre, la sortie ressemble à ceci au fil de la génération :
{
{"intent":
{"intent": "card_arrival",
{"intent": "card_arrival", "confidence": 0.95}Propulsé par
Chaque jeton correspond à une étape de décodage distincte, et chaque jeton de sortie est facturé. Si vous voulez un score de confiance, le modèle doit aussi écrire ce nombre. Ce chiffre est son auto-évaluation, et non une probabilité issue de ses mécanismes internes.
Un modèle de décision, lui, zappe l'étape d'écriture. Vous fournissez dès le départ les options, et il les évalue toutes face à l'entrée en un seul passage. Le résultat : une probabilité pour chaque option :
card_arrival 0.12
card_delivery_estimate 0.85
lost_or_stolen_card 0.01
...Propulsé par
Cela change trois aspects mesurables :
Latence : pas de boucle de décodage, la latence ne devrait donc pas croître avec la longueur de la réponse.
Coût : aucun jeton de sortie à facturer. Vous payez uniquement les jetons d'entrée, qui incluent le texte de la question et la description des options.
Confiance : la confiance provient des probabilités elles-mêmes, elle devrait donc refléter la fréquence à laquelle le modèle a raison.
La contrepartie : vous ne pouvez poser que des questions à réponses fermées. Un modèle de décision ne peut ni expliquer sa réponse, ni extraire une valeur, ni écrire du texte libre.
Démo : créer un classifieur d'intentions bancaires
Dans cette démo, nous allons construire un classifieur d'intentions pour la banque. Nous utiliserons le jeu de test de Banking77, un jeu de données public de messages clients étiquetés avec 77 intentions, et nous garderons 12 intentions faciles à confondre entre elles :
card_arrival et card_delivery_estimate
pending_card_payment, declined_card_payment et card_payment_fee_charged
pending_transfer, transfer_not_received_by_recipient et balance_not_updated_after_bank_transfer
lost_or_stolen_card, card_not_working, exchange_rate et top_up_failed
Des intentions proches rendent la tâche plus difficile, ce qui rend les scores de confiance plus intéressants à analyser.
Nous exécuterons le classifieur avec les deux modèles de deux façons :
Un message par requête : 180 messages (15 par intention), envoyés à chaque modèle un par un.
Plusieurs questions par requête : N messages placés dans une même entrée partagée, avec une question par message, pour N = 1, 5, 10, 25, 50 et 100.
Voici les paramètres que nous gardons identiques pour les deux modèles:
Paramètre
Valeur utilisée
Pourquoi
Modèle de décision
gemini-decision-1
Le modèle évalué
Modèle génératif
gemini-3.5-flash-lite
Le référent génératif économique utilisé dans la comparaison de l'annonce
Température de Flash-Lite
0,0
Supprime le bruit d'échantillonnage du référent
Niveau de "thinking" de Flash-Lite
minimal
Concentre la comparaison sur le décodage, pas le raisonnement
Format de sortie
Schéma JSON avec un enum de 12 labels
Flash-Lite ne peut renvoyer qu'une étiquette valide
Descriptions d'options
Une phrase courte par intention
Les deux modèles voient les mêmes définitions d'étiquettes
Appels de warmup
2 par modèle
Exclut la mise en place de la connexion des mesures
Répétitions (plusieurs questions par requête)
3 par configuration
Nous rapportons la médiane, pas un run unique
Remarque : ce sont des réglages de travail pour cette démo, non optimisés pour l'un ou l'autre modèle.
D'un notebook Colab (ou tout environnement Python 3)
google-genai version 3.2 ou supérieure
La Decisions API dispose d'un palier sans coût dans Google AI Studio pour le prototypage, vous pouvez donc l'essayer avant de payer. J'ai exécuté cette démo dans Colab, mais n'importe quel environnement Python 3 convient.
Commençons par installer les paquets :
!pip install-q-U"google-genai>=3.2" pandas matplotlibPropulsé par
Ici, google-genai est le SDK Python de Google pour l'API Gemini. Il nous fournit les méthodes client.decisions.create et client.interactions.create, qui envoient des requêtes aux APIs Decisions et Interactions. Nous utilisons pandas pour charger le jeu de données et organiser les résultats, et matplotlib pour tracer les figures.
Ensuite, créons le client. La Decisions API nécessite la version d'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"Propulsé par
Ici, genai.Client() lit la clé API depuis GEMINI_API_KEY défini dans les secrets de Colab ou en variable d'environnement, et http_options le pointe vers l'API v1beta, où se trouve la Decisions API.
Nous allons ensuite charger le jeu de données Banking77 et définir nos 12 intentions. Chaque intention reçoit une description d'une phrase que verront les deux modèles :
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))Propulsé par
Le fragment ci-dessus télécharge le split test de Banking77 en CSV et ne conserve que les lignes dont la catégorie correspond à l'une de nos 12 intentions. Il échantillonne ensuite 15 messages par intention avec une graine fixe, pour obtenir le même échantillon à chaque exécution. Le .sample(frac=1) final mélange les lignes pour panacher les intentions.
Nous obtenons ainsi 180 messages, 15 par intention.
Étape 2 : classifier avec la Decisions API
Une question choice prend un dictionnaire qui associe chaque identifiant d'option à une description. Nous passons le message dans input et posons une question, clé 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,}Propulsé par
La fonction decide_intent() envoie un message comme input et une question choice avec nos 12 intentions en options. Nous chronométrons l'appel avec time.perf_counter(), puis nous lisons le choix en tête, la confiance, toutes les probabilités des options et les comptes de jetons dans la réponse.
Chaque réponse contient trois champs :
choice : l'option à la probabilité la plus élevée
probabilities : une probabilité par option, qui somme à 1
confidence : la probabilité estimée que la meilleure réponse soit correcte
L'objet usage rapporte les jetons d'entrée, et total_output_tokens vaut toujours 0.
Voici le résultat pour le premier message de notre échantillon :
Le modèle a confondu deux intentions proches, mais sa confiance à 0,846 traduit une incertitude. Le point positif : la bonne intention, card_arrival, arrive en deuxième avec presque tout le reste de la probabilité (environ 0,15). Les autres options sont proches de zéro.
Étape 3 : classifier avec Flash-Lite
Pour le référent génératif, nous utilisons une sortie structurée avec un enum des mêmes 12 labels, afin que Flash-Lite ne puisse renvoyer qu'une étiquette valide. Nous demandons aussi une confiance entre 0 et 1, comme la plupart des applications obtiennent un score de confiance d'un modèle génératif :
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,}Propulsé par
La fonction generate_intent() construit un prompt avec les 12 intentions et leurs descriptions. Elle appelle Flash-Lite avec response_format réglé sur notre schéma JSON, de sorte que la sortie doit être un JSON valide avec l'un des 12 labels. La température est à 0 et le niveau de "thinking" à minimal pour garder une réponse stable et concise. Nous analysons ensuite interaction.output_text avec json.loads() et lisons les comptes de jetons dans interaction.usage.
J'ai testé le même message qu'à l'étape précédente avec Flash-Lite, et il a commis la même erreur avec une confiance plus élevée :
Les jetons de "thinking" sont à 0, ce qui confirme que le mode minimal a limité Flash-Lite à la rédaction de la réponse uniquement. Flash-Lite a utilisé moins de jetons d'entrée que Decision 1 (277 vs 337) car la Decisions API compte les descriptions d'options dans la question comme jetons d'entrée.
Étape 4 : classifier un message par requête
Envoyons désormais les 180 messages aux deux modèles, une requête à la fois, après deux appels de warmup chacun :
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"]Propulsé par
Cette boucle envoie chaque message aux deux fonctions et enregistre la prédiction, la confiance, la latence et les jetons comme une ligne. Nous transformons ensuite ces lignes en DataFrame et ajoutons une colonne correct qui indique si la prédiction correspond au label vérité.
Voici les résultats :
Métrique
Gemini Decision 1
Gemini 3.5 Flash-Lite
Exactitude
84,4 %
83,9 %
Latence médiane
325 ms
1 68 ms
Latence p90
412 ms
6 483 ms
Requête la plus lente
1,0 s
101,6 s
Requêtes > 5 s
0 sur 180
33 sur 180
Jetons d'entrée moyens
339
279
Jetons de sortie moyens
0
25
Trois enseignements se dégagent de ces métriques :
Exactitude : les deux modèles sont à peu près aussi précis.
Latence : Decision 1 est environ 3 fois plus rapide à la médiane et bien plus régulier, tandis que Flash-Lite présente une longue traîne de requêtes lentes.
Jetons : Decision 1 consomme plus de jetons d'entrée car les descriptions d'options comptent comme entrée, mais il ne génère aucun jeton de sortie.
Remarque : nos temps incluent l'aller-retour réseau depuis Colab ; considérez cet écart comme dépendant de l'environnement.
Étape 5 : vérifier la calibration
L'exactitude indique à quelle fréquence un modèle a raison, mais la calibration indique si sa confiance a du sens. Un modèle est bien calibré quand sa confiance correspond à son exactitude : s'il annonce 0,8 pour un groupe de réponses, environ 80 % devraient être correctes.
Pour le mesurer, nous regroupons les prédictions en 10 intervalles de confiance et comparons, pour chaque intervalle, la confiance moyenne à l'exactitude. L'erreur de calibration attendue (ECE) est l'écart moyen, pondéré par le volume de prédictions de chaque intervalle. Plus c'est bas, mieux c'est.
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 totalPropulsé par
La fonction ece() place chaque prédiction dans l'un des 10 intervalles selon sa confiance (0 à 0,1 ; 0,1 à 0,2 ; etc.). Pour chaque intervalle, elle prend l'écart entre la confiance moyenne et l'exactitude, le pondère par la part de prédictions de l'intervalle, puis additionne.
Voici comment les deux modèles se comparent :
Métrique
Gemini Decision 1
Gemini 3.5 Flash-Lite
Exactitude
84,4 %
83,9 %
Confiance moyenne
0,867
0,957
ECE
0,050
0,124
Confiance moyenne quand c'est correct
0,901
0,966
Confiance moyenne quand c'est faux
0,686
0,912
Figure : diagrammes de fiabilité pour les deux modèles
La confiance de Decision 1 est proche de son exactitude, avec une ECE de 0,050. Elle est aussi nettement plus faible quand le modèle se trompe (0,686) que quand il a raison (0,901).
Flash-Lite est trop sûr de lui. Il affiche 0,957 en moyenne tout en ayant raison 83,9 % du temps. Il n'a utilisé que 9 valeurs de confiance distinctes sur 180 réponses, dont 158 à 0,95 ou plus. Même ses réponses fausses affichaient en moyenne 0,912. Le chiffre ressemble à une probabilité, mais c'est l'estimation que le modèle écrit lui-même en texte.
La calibration est cruciale quand vous agissez sur le score. Un schéma courant consiste à accepter les réponses au-dessus d'un seuil de confiance et à envoyer le reste vers un modèle de secours ou un humain :
Seuil
Decision 1 : part conservée
Decision 1 : exactitude sur la part conservée
Flash-Lite : part conservée
Flash-Lite : exactitude sur la part conservée
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 %
Avec Decision 1, relever le seuil se comporte comme attendu. À 0,9, il conserve 63 % des messages avec 95,6 % d'exactitude. Avec Flash-Lite, le seuil aide peu, car la plupart des mauvaises réponses sont aussi à haute confiance. La documentation officielle recommande de choisir un seuil à partir d'exemples étiquetés de votre propre trafic.
Étape 6 : classifier 100 messages en une requête
La Decisions API peut répondre à jusqu'à 1 000 questions sur une même entrée partagée en une requête. Pour tester, nous mettons N messages clients dans une même entrée et posons une question par message.
Pour Decision 1, cela signifie N questions choice clées de m1 à 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.usagePropulsé par
Ici, la fonction build_batch() numérote les N premiers messages et les assemble en une entrée partagée. Puis decide_batch() crée une question choice par message, clée de m1 à mN, les envoie en une seule requête et lit une réponse par clé.
Pour Flash-Lite, nous envoyons la même entrée partagée avec un schéma JSON qui comporte N champs, chacun limité aux 12 labels. Chaque valeur de N utilise les mêmes messages pour les deux modèles, et chaque configuration est exécutée trois fois.
Questions par requête
Decision 1 : latence médiane
Flash-Lite : latence médiane
Decision 1 : jetons d'entrée
Flash-Lite : jetons entrée / sortie
1
318 ms
888 ms
344
291 / 14
5
353 ms
858 ms
1 554
369 / 64
10
398 ms
1 63 ms
3 056
456 / 129
25
546 ms
2 753 ms
7 570
710 / 350
50
592 ms
Échec
15 100
Échec
100
59 95 ms
Échec
30 309
Échec
Jusqu'à 25 questions, la latence médiane de Decision 1 est restée sous 550 ms. Celle de Flash-Lite a augmenté avec N, de moins d'1 s à 1–5 questions à 2,75 s à 25, car il doit écrire chaque réponse en jetons de sortie. Même à 50 questions, la médiane de Decision 1 était à 592 ms, bien que l'un des trois runs ait pris 70 s.
Deux points clés à retenir :
Flash-Lite a échoué à 50 et 100 questions : les lignes « Échec » du tableau ci-dessus renvoient toutes la même erreur 400. Le schéma a « trop d'états pour le service ». Un schéma avec 50 champs ou plus, chacun limité à 12 labels, dépasse ce que l'API accepte.
Decision 1 a ralenti à 100 questions : chaque question répète les 12 descriptions d'options, environ 300 jetons par question, si bien que la requête a atteind 30 309 jetons, alors que la promesse de latence quasi constante de Google couvre des contextes jusqu'à 16K jetons.
Étape 7 : élaguer les requêtes
Question évidente : peut-on corriger le ralentissement et les échecs ? Pour Decision 1, nous utilisons des descriptions d'options vides (« »). Pour Flash-Lite, nous demandons une seule liste de N labels au lieu de N champs séparés :
# 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"],}Propulsé par
Voici les résultats de Decision 1 avec des descriptions vides :
Questions par requête
Latence médiane
Exactitude
Jetons d'entrée
25
357 ms
84,0 %
3 995
50
649 ms
78,0 %
7 950
100
1 603 ms
83,0 %
16 09
Supprimer les descriptions a grosso modo divisé par deux les jetons d'entrée. À 100 questions, la requête tombe à environ 16K jetons et la latence médiane passe de 59 s à 1,6 s. L'exactitude baisse un peu à 25 et 50 questions, donc des descriptions courtes sont un meilleur compromis que rien, surtout pour des intentions similaires.
Le schéma en liste n'a pas aidé le modèle Flash-Lite. Il a fonctionné à 25 questions, mais échoue toujours à 50 et 100.
Étape 8 : comparer les coûts
Enfin, calculons le coût à partir des comptes de jetons retournés par chaque API, en utilisant les prix du palier payant :
Modèle
Prix entrée pour 1 M de jetons
Prix sortie pour 1 M de jetons
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (jetons de "thinking" inclus)
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)/1e6Propulsé par
La fonction cost_per_request() multiplie chaque compte de jetons par son prix pour 1 million de jetons. Pour Decision 1, seuls les jetons d'entrée comptent. Pour Flash-Lite, les jetons de "thinking" sont facturés au prix des sorties, nous les ajoutons donc aux jetons de sortie.
Voici le coût pour 1 000 requêtes pour chaque configuration :
Configuration
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 message par requête
$0,034
$0,147
4,3x
5 questions par requête
$0,155
$0,271
1,7x
10 questions par requête
$0,306
$0,459
1,5x
25 questions par requête
$0,757
$1,088
1,4x
25 questions, configurations élaguées (Étape 7)
$0,400
$0,831
2,1x
50 questions par requête
$1,510
Échec
n/a
100 questions, descriptions vides
$1,601
Échec
n/a
Sur les messages unitaires, Decision 1 était 4,3x moins cher, mais l'écart se réduit quand vous regroupez davantage de questions dans une requête. L'entrée partagée est facturée une fois dans les deux APIs. Mais chaque question Decision 1 embarque sa propre instruction et les 12 descriptions d'options, tandis que Flash-Lite voit la liste des labels une seule fois et paie une courte sortie par réponse. À 25 questions, Decision 1 a utilisé 7 570 jetons d'entrée contre 710 en entrée et 350 en sortie pour Flash-Lite.
Remarque : la Decisions API ne prend pas en charge la mise en cache de contexte ni la Batch API. Si vous envoyez la même entrée dans plusieurs requêtes, elle est facturée à chaque fois. Si vous avez de nombreuses questions sur la même entrée, posez-les dans une seule requête plutôt que de les étaler.
Quand utiliser chaque approche
D'après les exécutions ci-dessus, un modèle de décision est plus indiqué quand :
La réponse provient d'un ensemble fixe d'options, comme des intentions, routes, outils ou labels de politique
La décision se trouve sur le chemin de la requête, où chaque utilisateur attend
Vous voulez agir selon la confiance, par exemple en envoyant les cas ambigus vers un fallback ou un humain
Vous devez poser de nombreuses questions indépendantes sur une même entrée, en une requête
Un modèle génératif reste le meilleur choix quand :
Vous avez besoin d'une explication, d'une valeur extraite ou de texte libre
L'ensemble des réponses possibles est ouvert ou change selon la requête
Vous avez déjà fait un appel génératif sur cette entrée et pouvez y ajouter la classification
Utilisez la Decisions API quand vous avez besoin de
Utilisez l'Interactions API quand vous avez besoin de
Une probabilité oui/non, un choix dans un ensemble fixe, ou une note sur une échelle définie
Texte généré, résumés ou explications
Probabilités calibrées que vous pouvez seøuiller
Valeurs ou objets extraits qui suivent votre propre schéma JSON
De nombreux contrôles indépendants sur une même entrée en un appel
Appels d'outils avec arguments
Faible latence et coût nul en jetons de sortie
Raisonnement en plusieurs étapes
Conclusion
Dans ce tutoriel, nous avons construit un classifieur d'intentions bancaires avec Gemini Decision 1 et Gemini 3.5 Flash-Lite, puis comparé les deux modèles sur l'exactitude, la latence, la calibration et le coût. Quatre enseignements :
Match nul en exactitude : 84,4 % pour Decision 1 et 83,9 % pour Flash-Lite, avec le même verdict sur 163 des 180 messages.
Decision 1 plus rapide et plus prévisible : latence médiane de 325 ms contre 1 68 ms, et requête la plus lente à 1,0 s contre 101,6 s.
Une confiance exploitable pour Decision 1 : ECE à 0,050 contre 0,124, et en relevant le seuil à 0,9, l'exactitude sur les réponses conservées passe de 84,4 % à 95,6 %. La confiance auto-reportée de Flash-Lite distingue peu le vrai du faux.
Le coût et la mise à l'échelle dépendent de la façon d'écrire les questions : Decision 1 était 4,3x moins cher sur des messages unitaires, mais chaque question paie pour ses descriptions d'options. Maintenez donc le total d'entrée sous ~16K jetons et gardez des descriptions d'options courtes.
Ces résultats proviennent d'une seule tâche, d'un seul jeu de données et d'un petit nombre d'exécutions depuis un notebook Colab. Considérez-les comme des observations de démo, pas comme des allégations générales de performance.
Je suis experte Google Developers en ML (Gen AI), triple experte Kaggle et ambassadrice Women Techmakers, avec plus de trois ans d’expérience dans la tech. J’ai cofondé une startup dans le domaine de la santé en 2020 et je poursuis actuellement un master en informatique à Georgia Tech, avec une spécialisation en apprentissage automatique.
FAQs
Quelle est la différence entre la Decisions API et une API générative ?⌄
Une API générative écrit sa réponse jeton par jeton et facture chaque jeton de sortie. La Decisions API évalue un ensemble fixe d'options en un seul passage et renvoie une probabilité pour chacune. Elle ne génère aucun jeton de sortie, vous ne payez donc que l'entrée.
Gemini Decision 1 est-il plus précis que Gemini 3.5 Flash-Lite ?⌄
Pas dans notre test. Sur 180 messages bancaires, l'exactitude était de 84,4 % pour Decision 1 et 83,9 % pour Flash-Lite. Les différences mesurées portaient sur la latence, la calibration et le coût.
Pourquoi Decision 1 utilise-t-il plus de jetons d'entrée que Flash-Lite ?⌄
L'instruction de chaque question et les descriptions d'options comptent comme entrée. Avec 12 options décrites, cela ajoute environ 300 jetons par question dans notre test. Des descriptions courtes ou vides réduisent cela.
La latence reste-t-elle stable quand j'ajoute des questions ?⌄
Dans nos exécutions, la médiane est restée sous 650 ms jusqu'à 50 questions. À 100 questions avec des descriptions complètes, la requête a atteint environ 30K jetons et a pris 48 à 59 s. Avec des descriptions vides, les mêmes 100 questions tiennent en ~16K jetons et prennent 1,6 s.
Quels types de questions la Decisions API prend-elle en charge ?⌄
La Decisions API prend en charge trois types de questions, dont noul pour les vérifications oui/non, choice pour choisir une option parmi 2 à 255, et score pour noter selon une grille ordonnée. Vous pouvez mêler les trois dans une même requête.
L'essor du développement de l'intelligence artificielle (IA) a entraîné une augmentation notable de la demande en matière de calcul, d'où la nécessité de disposer de solutions matérielles robustes. Les unités de traitement graphique (GPU) et les unités de traitement tensoriel (TPU) sont devenues des technologies essentielles pour répondre à ces demandes.
Découvrez les principaux types d'agents d'intelligence artificielle, comment ils interagissent avec les environnements et comment ils sont utilisés dans les différents secteurs d'activité. Comprendre les agents réflexes simples, les agents basés sur un modèle, les agents basés sur un but, les agents basés sur l'utilité, les agents d'apprentissage, etc.
Apprenez l'essentiel de l'architecture d'un entrepôt de données, des composants clés aux meilleures pratiques, pour construire un système de données évolutif et efficace !
Apprenez à utiliser l'API DeepSeek : choix des modèles, gestion des paramètres, optimisation des coûts, mise en cache du contexte et optimisation du chain-of-thought.
Analyze data smarter with Gemini in Google Sheets. Use AI-powered insights, formula suggestions, and automation to simplify spreadsheets and boost productivity.
La plupart des applications basées sur des LLM sont truffées de micro-décisions : quel outil l'agent doit-il appeler ? Quel modèle doit traiter cette requête ? Ce message enfreint-il une politique ?
Aujourd'hui, beaucoup d'équipes posent ces questions à un modèle génératif qui rend une réponse en texte, puis analysent ce texte pour prendre la décision.
La Gemini Decisions API de Google adopte une autre approche. Elle utilise le modèle Gemini Decision 1 pour noter un ensemble fixe d'options en un seul passage et renvoie une probabilité par option, sans aucun jeton de sortie facturé.
Dans ce tutoriel, nous allons exécuter la même tâche de classification d'intention sur deux configurations :
Nous les comparerons sur l'exactitude, la latence, l'utilisation de jetons, le coût et la calibration, puis nous passerons de 1 à 100 questions dans une seule requête.
Au terme de ce tutoriel, vous saurez :
Appeler la Decisions API avec des questions
choiceet lire ses probabilités et scores de confianceConstruire une base générative avec l'Interactions API et un schéma JSON
Mesurer la latence, l'utilisation de jetons et le coût pour les deux approches
Vérifier la fiabilité d'un score de confiance à l'aide d'un diagramme de fiabilité et de l'erreur de calibration attendue (ECE)
Décider quand un modèle de décision convient mieux à votre application qu'un modèle génératif
Vous pouvez exécuter l'intégralité du code dans ce Google Colab.
Modèles de décision vs modèles génératifs
Avant d'entrer dans le détail de leur fonctionnement, définissons les deux termes.
Voici un exemple.
Un client écrit à une banque : "Ma carte n'est pas encore arrivée. Quand la recevrai-je ?"
Si vous demandez à un modèle génératif « Que veut ce client ? », il pourrait répondre :
« Le client attend une nouvelle carte et veut savoir quand elle arrivera. »
C'est une bonne réponse pour un humain. Mais si votre application doit router le message vers la bonne équipe, votre code doit maintenant convertir cette phrase en étiquette. Vous pouvez imposer une étiquette avec un schéma JSON, mais le modèle l'écrit toujours jeton par jeton.
En revanche, si vous posez la même question à un modèle de décision, vous fournissez d'abord les options, par exemple
card_arrival,lost_or_stolen_cardetexchange_rate. Il renvoie une probabilité pour chacune :Votre code peut alors agir directement sur cette probabilité : router vers l'équipe carte si
card_arrivaldépasse un seuil, et envoyer à un humain sinon. En bref :Modèle génératif
Modèle de décision
Renvoie
Un texte qu'il écrit
Une probabilité pour chaque option définie
Réponses possibles
Ouvertes
Ensemble fixe
Adapté à
Réponses, résumés, explications et extraction
Routage, sélection d'outils, contrôles de politiques et évaluation
En pratique, beaucoup d'applications utilisent un modèle génératif pour les deux rôles. C'est ce que nous allons tester dans la section suivante : un modèle de décision fait-il mieux la partie classification qu'un modèle génératif ?
Quand vous utilisez un modèle génératif comme classifieur, il écrit la réponse jeton par jeton. Pour une réponse JSON comme la nôtre, la sortie ressemble à ceci au fil de la génération :
Chaque jeton correspond à une étape de décodage distincte, et chaque jeton de sortie est facturé. Si vous voulez un score de confiance, le modèle doit aussi écrire ce nombre. Ce chiffre est son auto-évaluation, et non une probabilité issue de ses mécanismes internes.
Un modèle de décision, lui, zappe l'étape d'écriture. Vous fournissez dès le départ les options, et il les évalue toutes face à l'entrée en un seul passage. Le résultat : une probabilité pour chaque option :
Cela change trois aspects mesurables :
La contrepartie : vous ne pouvez poser que des questions à réponses fermées. Un modèle de décision ne peut ni expliquer sa réponse, ni extraire une valeur, ni écrire du texte libre.
Démo : créer un classifieur d'intentions bancaires
Dans cette démo, nous allons construire un classifieur d'intentions pour la banque. Nous utiliserons le jeu de test de Banking77, un jeu de données public de messages clients étiquetés avec 77 intentions, et nous garderons 12 intentions faciles à confondre entre elles :
card_arrivaletcard_delivery_estimatepending_card_payment,declined_card_paymentetcard_payment_fee_chargedpending_transfer,transfer_not_received_by_recipientetbalance_not_updated_after_bank_transferlost_or_stolen_card,card_not_working,exchange_rateettop_up_failedDes intentions proches rendent la tâche plus difficile, ce qui rend les scores de confiance plus intéressants à analyser.
Nous exécuterons le classifieur avec les deux modèles de deux façons :
Voici les paramètres que nous gardons identiques pour les deux modèles:
Paramètre
Valeur utilisée
Pourquoi
Modèle de décision
gemini-decision-1Le modèle évalué
Modèle génératif
gemini-3.5-flash-liteLe référent génératif économique utilisé dans la comparaison de l'annonce
Température de Flash-Lite
0,0
Supprime le bruit d'échantillonnage du référent
Niveau de "thinking" de Flash-Lite
minimalConcentre la comparaison sur le décodage, pas le raisonnement
Format de sortie
Schéma JSON avec un
enumde 12 labelsFlash-Lite ne peut renvoyer qu'une étiquette valide
Descriptions d'options
Une phrase courte par intention
Les deux modèles voient les mêmes définitions d'étiquettes
Appels de warmup
2 par modèle
Exclut la mise en place de la connexion des mesures
Répétitions (plusieurs questions par requête)
3 par configuration
Nous rapportons la médiane, pas un run unique
Remarque : ce sont des réglages de travail pour cette démo, non optimisés pour l'un ou l'autre modèle.
Étape 1 : prérequis et configuration
Pour suivre, vous avez besoin :
D'une clé API Gemini obtenue depuis Google AI Studio
D'un notebook Colab (ou tout environnement Python 3)
google-genaiversion 3.2 ou supérieureLa Decisions API dispose d'un palier sans coût dans Google AI Studio pour le prototypage, vous pouvez donc l'essayer avant de payer. J'ai exécuté cette démo dans Colab, mais n'importe quel environnement Python 3 convient.
Commençons par installer les paquets :
Ici,
google-genaiest le SDK Python de Google pour l'API Gemini. Il nous fournit les méthodesclient.decisions.createetclient.interactions.create, qui envoient des requêtes aux APIs Decisions et Interactions. Nous utilisonspandaspour charger le jeu de données et organiser les résultats, etmatplotlibpour tracer les figures.Ensuite, créons le client. La Decisions API nécessite la version d'API v1beta :
Ici,
genai.Client()lit la clé API depuisGEMINI_API_KEYdéfini dans les secrets de Colab ou en variable d'environnement, ethttp_optionsle pointe vers l'API v1beta, où se trouve la Decisions API.Nous allons ensuite charger le jeu de données Banking77 et définir nos 12 intentions. Chaque intention reçoit une description d'une phrase que verront les deux modèles :
Le fragment ci-dessus télécharge le split test de Banking77 en CSV et ne conserve que les lignes dont la catégorie correspond à l'une de nos 12 intentions. Il échantillonne ensuite 15 messages par intention avec une graine fixe, pour obtenir le même échantillon à chaque exécution. Le
.sample(frac=1)final mélange les lignes pour panacher les intentions.Nous obtenons ainsi 180 messages, 15 par intention.
Étape 2 : classifier avec la Decisions API
Une question
choiceprend un dictionnaire qui associe chaque identifiant d'option à une description. Nous passons le message dansinputet posons une question, cléintent:La fonction
decide_intent()envoie un message commeinputet une questionchoiceavec nos 12 intentions en options. Nous chronométrons l'appel avectime.perf_counter(), puis nous lisons le choix en tête, la confiance, toutes les probabilités des options et les comptes de jetons dans la réponse.Chaque réponse contient trois champs :
choice: l'option à la probabilité la plus élevéeprobabilities: une probabilité par option, qui somme à 1confidence: la probabilité estimée que la meilleure réponse soit correcteL'objet
usagerapporte les jetons d'entrée, ettotal_output_tokensvaut toujours 0.Voici le résultat pour le premier message de notre échantillon :
Le modèle a confondu deux intentions proches, mais sa confiance à 0,846 traduit une incertitude. Le point positif : la bonne intention,
card_arrival, arrive en deuxième avec presque tout le reste de la probabilité (environ 0,15). Les autres options sont proches de zéro.Étape 3 : classifier avec Flash-Lite
Pour le référent génératif, nous utilisons une sortie structurée avec un
enumdes mêmes 12 labels, afin que Flash-Lite ne puisse renvoyer qu'une étiquette valide. Nous demandons aussi une confiance entre 0 et 1, comme la plupart des applications obtiennent un score de confiance d'un modèle génératif :La fonction
generate_intent()construit un prompt avec les 12 intentions et leurs descriptions. Elle appelle Flash-Lite avecresponse_formatréglé sur notre schéma JSON, de sorte que la sortie doit être un JSON valide avec l'un des 12 labels. La température est à0et le niveau de "thinking" àminimalpour garder une réponse stable et concise. Nous analysons ensuiteinteraction.output_textavecjson.loads()et lisons les comptes de jetons dansinteraction.usage.J'ai testé le même message qu'à l'étape précédente avec Flash-Lite, et il a commis la même erreur avec une confiance plus élevée :
Les jetons de "thinking" sont à 0, ce qui confirme que le mode
minimala limité Flash-Lite à la rédaction de la réponse uniquement. Flash-Lite a utilisé moins de jetons d'entrée que Decision 1 (277 vs 337) car la Decisions API compte les descriptions d'options dans la question comme jetons d'entrée.Étape 4 : classifier un message par requête
Envoyons désormais les 180 messages aux deux modèles, une requête à la fois, après deux appels de warmup chacun :
Cette boucle envoie chaque message aux deux fonctions et enregistre la prédiction, la confiance, la latence et les jetons comme une ligne. Nous transformons ensuite ces lignes en DataFrame et ajoutons une colonne
correctqui indique si la prédiction correspond au label vérité.Voici les résultats :
Métrique
Gemini Decision 1
Gemini 3.5 Flash-Lite
Exactitude
84,4 %
83,9 %
Latence médiane
325 ms
1 68 ms
Latence p90
412 ms
6 483 ms
Requête la plus lente
1,0 s
101,6 s
Requêtes > 5 s
0 sur 180
33 sur 180
Jetons d'entrée moyens
339
279
Jetons de sortie moyens
0
25
Trois enseignements se dégagent de ces métriques :
Remarque : nos temps incluent l'aller-retour réseau depuis Colab ; considérez cet écart comme dépendant de l'environnement.
Étape 5 : vérifier la calibration
L'exactitude indique à quelle fréquence un modèle a raison, mais la calibration indique si sa confiance a du sens. Un modèle est bien calibré quand sa confiance correspond à son exactitude : s'il annonce 0,8 pour un groupe de réponses, environ 80 % devraient être correctes.
Pour le mesurer, nous regroupons les prédictions en 10 intervalles de confiance et comparons, pour chaque intervalle, la confiance moyenne à l'exactitude. L'erreur de calibration attendue (ECE) est l'écart moyen, pondéré par le volume de prédictions de chaque intervalle. Plus c'est bas, mieux c'est.
La fonction
ece()place chaque prédiction dans l'un des 10 intervalles selon sa confiance (0 à 0,1 ; 0,1 à 0,2 ; etc.). Pour chaque intervalle, elle prend l'écart entre la confiance moyenne et l'exactitude, le pondère par la part de prédictions de l'intervalle, puis additionne.Voici comment les deux modèles se comparent :
Métrique
Gemini Decision 1
Gemini 3.5 Flash-Lite
Exactitude
84,4 %
83,9 %
Confiance moyenne
0,867
0,957
ECE
0,050
0,124
Confiance moyenne quand c'est correct
0,901
0,966
Confiance moyenne quand c'est faux
0,686
0,912
Figure : diagrammes de fiabilité pour les deux modèles
La confiance de Decision 1 est proche de son exactitude, avec une ECE de 0,050. Elle est aussi nettement plus faible quand le modèle se trompe (0,686) que quand il a raison (0,901).
Flash-Lite est trop sûr de lui. Il affiche 0,957 en moyenne tout en ayant raison 83,9 % du temps. Il n'a utilisé que 9 valeurs de confiance distinctes sur 180 réponses, dont 158 à 0,95 ou plus. Même ses réponses fausses affichaient en moyenne 0,912. Le chiffre ressemble à une probabilité, mais c'est l'estimation que le modèle écrit lui-même en texte.
La calibration est cruciale quand vous agissez sur le score. Un schéma courant consiste à accepter les réponses au-dessus d'un seuil de confiance et à envoyer le reste vers un modèle de secours ou un humain :
Seuil
Decision 1 : part conservée
Decision 1 : exactitude sur la part conservée
Flash-Lite : part conservée
Flash-Lite : exactitude sur la part conservée
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 %
Avec Decision 1, relever le seuil se comporte comme attendu. À 0,9, il conserve 63 % des messages avec 95,6 % d'exactitude. Avec Flash-Lite, le seuil aide peu, car la plupart des mauvaises réponses sont aussi à haute confiance. La documentation officielle recommande de choisir un seuil à partir d'exemples étiquetés de votre propre trafic.
Étape 6 : classifier 100 messages en une requête
La Decisions API peut répondre à jusqu'à 1 000 questions sur une même entrée partagée en une requête. Pour tester, nous mettons N messages clients dans une même entrée et posons une question par message.
Pour Decision 1, cela signifie N questions
choiceclées dem1àmN:Ici, la fonction
build_batch()numérote les N premiers messages et les assemble en une entrée partagée. Puisdecide_batch()crée une questionchoicepar message, clée dem1àmN, les envoie en une seule requête et lit une réponse par clé.Pour Flash-Lite, nous envoyons la même entrée partagée avec un schéma JSON qui comporte N champs, chacun limité aux 12 labels. Chaque valeur de N utilise les mêmes messages pour les deux modèles, et chaque configuration est exécutée trois fois.
Questions par requête
Decision 1 : latence médiane
Flash-Lite : latence médiane
Decision 1 : jetons d'entrée
Flash-Lite : jetons entrée / sortie
1
318 ms
888 ms
344
291 / 14
5
353 ms
858 ms
1 554
369 / 64
10
398 ms
1 63 ms
3 056
456 / 129
25
546 ms
2 753 ms
7 570
710 / 350
50
592 ms
Échec
15 100
Échec
100
59 95 ms
Échec
30 309
Échec
Jusqu'à 25 questions, la latence médiane de Decision 1 est restée sous 550 ms. Celle de Flash-Lite a augmenté avec N, de moins d'1 s à 1–5 questions à 2,75 s à 25, car il doit écrire chaque réponse en jetons de sortie. Même à 50 questions, la médiane de Decision 1 était à 592 ms, bien que l'un des trois runs ait pris 70 s.
Deux points clés à retenir :
Étape 7 : élaguer les requêtes
Question évidente : peut-on corriger le ralentissement et les échecs ? Pour Decision 1, nous utilisons des descriptions d'options vides (« »). Pour Flash-Lite, nous demandons une seule liste de N labels au lieu de N champs séparés :
Voici les résultats de Decision 1 avec des descriptions vides :
Questions par requête
Latence médiane
Exactitude
Jetons d'entrée
25
357 ms
84,0 %
3 995
50
649 ms
78,0 %
7 950
100
1 603 ms
83,0 %
16 09
Supprimer les descriptions a grosso modo divisé par deux les jetons d'entrée. À 100 questions, la requête tombe à environ 16K jetons et la latence médiane passe de 59 s à 1,6 s. L'exactitude baisse un peu à 25 et 50 questions, donc des descriptions courtes sont un meilleur compromis que rien, surtout pour des intentions similaires.
Le schéma en liste n'a pas aidé le modèle Flash-Lite. Il a fonctionné à 25 questions, mais échoue toujours à 50 et 100.
Étape 8 : comparer les coûts
Enfin, calculons le coût à partir des comptes de jetons retournés par chaque API, en utilisant les prix du palier payant :
Modèle
Prix entrée pour 1 M de jetons
Prix sortie pour 1 M de jetons
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (jetons de "thinking" inclus)
La fonction
cost_per_request()multiplie chaque compte de jetons par son prix pour 1 million de jetons. Pour Decision 1, seuls les jetons d'entrée comptent. Pour Flash-Lite, les jetons de "thinking" sont facturés au prix des sorties, nous les ajoutons donc aux jetons de sortie.Voici le coût pour 1 000 requêtes pour chaque configuration :
Configuration
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 message par requête
$0,034
$0,147
4,3x
5 questions par requête
$0,155
$0,271
1,7x
10 questions par requête
$0,306
$0,459
1,5x
25 questions par requête
$0,757
$1,088
1,4x
25 questions, configurations élaguées (Étape 7)
$0,400
$0,831
2,1x
50 questions par requête
$1,510
Échec
n/a
100 questions, descriptions vides
$1,601
Échec
n/a
Sur les messages unitaires, Decision 1 était 4,3x moins cher, mais l'écart se réduit quand vous regroupez davantage de questions dans une requête. L'entrée partagée est facturée une fois dans les deux APIs. Mais chaque question Decision 1 embarque sa propre instruction et les 12 descriptions d'options, tandis que Flash-Lite voit la liste des labels une seule fois et paie une courte sortie par réponse. À 25 questions, Decision 1 a utilisé 7 570 jetons d'entrée contre 710 en entrée et 350 en sortie pour Flash-Lite.
Remarque : la Decisions API ne prend pas en charge la mise en cache de contexte ni la Batch API. Si vous envoyez la même entrée dans plusieurs requêtes, elle est facturée à chaque fois. Si vous avez de nombreuses questions sur la même entrée, posez-les dans une seule requête plutôt que de les étaler.
Quand utiliser chaque approche
D'après les exécutions ci-dessus, un modèle de décision est plus indiqué quand :
Un modèle génératif reste le meilleur choix quand :
Utilisez la Decisions API quand vous avez besoin de
Utilisez l'Interactions API quand vous avez besoin de
Une probabilité oui/non, un choix dans un ensemble fixe, ou une note sur une échelle définie
Texte généré, résumés ou explications
Probabilités calibrées que vous pouvez seøuiller
Valeurs ou objets extraits qui suivent votre propre schéma JSON
De nombreux contrôles indépendants sur une même entrée en un appel
Appels d'outils avec arguments
Faible latence et coût nul en jetons de sortie
Raisonnement en plusieurs étapes
Conclusion
Dans ce tutoriel, nous avons construit un classifieur d'intentions bancaires avec Gemini Decision 1 et Gemini 3.5 Flash-Lite, puis comparé les deux modèles sur l'exactitude, la latence, la calibration et le coût. Quatre enseignements :
Ces résultats proviennent d'une seule tâche, d'un seul jeu de données et d'un petit nombre d'exécutions depuis un notebook Colab. Considérez-les comme des observations de démo, pas comme des allégations générales de performance.