Gemini Decisions API: prueba del nuevo modelo de decisiones de Google en latencia y coste
Descubre cómo Gemini Decision 1 puntúa opciones fijas sin generar texto, crea un clasificador de intenciones con la Decisions API y compáralo con Gemini 3.5 Flash-Lite en precisión, latencia, calibración y coste.
La mayoría de las apps con LLM están llenas de microdecisiones: ¿qué herramienta debe llamar el agente?, ¿qué modelo debe gestionar esta consulta?, ¿este mensaje incumple alguna política?
Hoy, muchos equipos responden a estas preguntas pidiéndole a un modelo generativo que escriba la respuesta como texto y luego parsean ese texto para tomar una decisión.
La Gemini Decisions API de Google propone otro enfoque. Usa el modelo Gemini Decision 1 para puntuar un conjunto fijo de opciones en una sola pasada y devuelve una probabilidad para cada opción, sin facturar tokens de salida.
En este tutorial, ejecutaremos la misma tarea de clasificación de intenciones con dos configuraciones:
Gemini Decision 1 a través de la Decisions API
Gemini 3.5 Flash-Lite a través de la Interactions API, con salida JSON estructurada
Los compararemos en precisión, latencia, uso de tokens, coste y calibración, y luego pasaremos de 1 a 100 preguntas en una sola solicitud.
Al final del tutorial, sabrás cómo:
Llamar a la Decisions API con preguntas choice y leer sus probabilidades y puntuaciones de confianza
Crear una línea base generativa con la Interactions API y un esquema JSON
Medir la latencia, el uso de tokens y el coste en ambos enfoques
Comprobar si la confianza de un modelo es fiable con un diagrama de fiabilidad y el error de calibración esperado (ECE)
Decidir cuándo un modelo de decisiones encaja mejor en tu app que uno generativo
Puedes ejecutar el código completo en este Google Colab.
Modelos de decisión vs. modelos generativos
Antes de ver cómo funciona cada uno, definamos ambos términos.
Modelo generativo: genera contenido nuevo. Le das un prompt y escribe la respuesta token a token. Esa respuesta puede ser una contestación, un resumen, código o una etiqueta. Gemini 3.5 Flash-Lite, como la mayoría de LLMs que usamos en apps de chat, es un modelo generativo.
Modelo de decisiones: elige entre las opciones que defines. Le das una entrada y una lista fija de posibles respuestas, y te devuelve la probabilidad de cada opción sin escribir una sola línea de texto. Gemini Decision 1 es un modelo de decisiones.
Aquí tienes un ejemplo.
Una clienta escribe a un banco: "Mi tarjeta aún no ha llegado. ¿Cuándo llegará?"
Si le preguntas a un modelo generativo: "¿Qué quiere esta clienta?", podría responder:
«La clienta está esperando una tarjeta nueva y quiere saber cuándo llegará».
Es una buena respuesta para que la lea una persona. Pero si tu app necesita enrutar el mensaje al equipo adecuado, tu código tiene que convertir esa frase en una etiqueta. Puedes forzar una etiqueta con un esquema JSON, pero el modelo seguirá "escribiéndola" token a token.
En cambio, si preguntas lo mismo a un modelo de decisiones, primero le pasas las opciones, por ejemplo card_arrival, lost_or_stolen_card y exchange_rate. Devuelve una probabilidad por cada una:
card_arrival 0.91
lost_or_stolen_card 0.06
exchange_rate 0.03Con la tecnología de
Tu código puede actuar directamente sobre esa probabilidad: enrutar al equipo de tarjetas si card_arrival supera un umbral y mandarlo a una persona si no. En resumen:
Modelo generativo
Modelo de decisiones
Devuelve
Texto que escribe
Una probabilidad por cada opción que defines
Respuestas posibles
Abiertas
Conjunto fijo
Bueno para
Respuestas, resúmenes, explicaciones y extracción
Enrutado, selección de herramientas, comprobaciones de políticas y evaluación
En la práctica, muchas apps usan un modelo generativo para ambos trabajos. Eso es lo que probaremos a continuación: si un modelo de decisiones hace mejor la parte de clasificación que uno generativo.
Cuando usas un modelo generativo como clasificador, escribe la respuesta token a token. Para una respuesta JSON como la nuestra, la salida va generándose así:
{
{"intent":
{"intent": "card_arrival",
{"intent": "card_arrival", "confidence": 0.95}Con la tecnología de
Cada token es un paso de decodificación distinto y cada token de salida se factura. Si quieres una puntuación de confianza, el modelo también tiene que escribir ese número. Ese número es la propia estimación del modelo sobre sí mismo, no una probabilidad medida en sus internos.
Un modelo de decisiones, en cambio, se salta la fase de escritura. Le das las opciones por adelantado y puntúa todas frente a la entrada en una pasada. El resultado es una probabilidad para cada opción:
card_arrival 0.12
card_delivery_estimate 0.85
lost_or_stolen_card 0.01
...Con la tecnología de
Esto cambia tres cosas que puedes medir:
Latencia: no hay bucle de decodificación, así que la latencia no debería crecer con la longitud de la respuesta.
Coste: no hay tokens de salida que facturar. Solo pagas por los tokens de entrada, que incluyen el texto de la pregunta y las descripciones de las opciones.
Confianza: la confianza proviene de las propias probabilidades, por lo que debería reflejar con qué frecuencia acierta el modelo.
La contrapartida es que solo puedes hacer preguntas de conjunto cerrado. Un modelo de decisiones no puede explicar su respuesta, extraer un valor ni escribir texto libre.
Demo: crear un clasificador de intenciones bancarias
En esta demo, construiremos un clasificador de intenciones bancarias. Usaremos la partición de test de Banking77, un dataset público de mensajes de clientes etiquetados con 77 intenciones, y nos quedaremos con 12 intenciones fáciles de confundir entre sí:
card_arrival y card_delivery_estimate
pending_card_payment, declined_card_payment y card_payment_fee_charged
pending_transfer, transfer_not_received_by_recipient y balance_not_updated_after_bank_transfer
lost_or_stolen_card, card_not_working, exchange_rate y top_up_failed
Intenciones similares hacen la tarea más difícil, lo que vuelve más interesante analizar las puntuaciones de confianza.
Ejecutaremos el clasificador con ambos modelos de dos formas:
Un mensaje por solicitud: 180 mensajes (15 por intención), enviados a cada modelo uno a uno.
Muchas preguntas por solicitud: N mensajes en una entrada compartida, con una pregunta por mensaje, para N = 1, 5, 10, 25, 50 y 100.
Estos son los ajustes que mantenemos iguales en ambos modelos:
Ajuste
Valor usado
Por qué
Modelo de decisiones
gemini-decision-1
El modelo bajo prueba
Modelo generativo
gemini-3.5-flash-lite
La línea base generativa rentable usada en el post de lanzamiento
Temperatura de Flash-Lite
0.0
Elimina el ruido de muestreo de la línea base
Nivel de pensamiento de Flash-Lite
minimal
Mantiene la comparación en la decodificación, no en el razonamiento
Formato de salida
Esquema JSON con un enum de las 12 etiquetas
Flash-Lite solo puede devolver una etiqueta válida
Descripciones de opciones
Una frase corta por intención
Ambos modelos ven las mismas definiciones de etiquetas
Llamadas de calentamiento
2 por modelo
Saca la configuración de conexión de las medidas
Repeticiones (muchas preguntas por solicitud)
3 por ajuste
Reportamos la mediana, no una sola ejecución
Nota: Son ajustes funcionales para esta demo, no configuraciones afinadas para ninguno de los modelos.
Un cuaderno de Colab (o cualquier entorno de Python 3)
google-genai versión 3.2 o posterior
La Decisions API tiene un nivel sin coste en Google AI Studio para prototipado, así que puedes probarla antes de pagar. Yo ejecuté esta demo en Colab, pero usa cualquier entorno Python 3 que prefieras.
Aquí, google-genai es el SDK de Google en Python para la Gemini API. Nos da los métodos client.decisions.create y client.interactions.create, que envían solicitudes a la Decisions API y a la Interactions API. Usamos pandas para cargar el dataset y organizar resultados, y matplotlib para representar las figuras.
Después creamos el cliente. La Decisions API necesita la versión v1beta del API:
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"Con la tecnología de
Aquí, genai.Client() lee la clave de API de GEMINI_API_KEY definida en los secretos de Colab o como variable de entorno, y http_options la dirige al API v1beta, donde está la Decisions API.
Luego cargaremos el dataset Banking77 y definiremos nuestras 12 intenciones. Cada intención tiene una descripción de una frase que verán ambos modelos:
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))Con la tecnología de
El fragmento anterior descarga la partición de test de Banking77 como CSV y mantiene solo las filas con una de nuestras 12 intenciones. Luego toma 15 mensajes por intención con una semilla fija para reproducibilidad. El .sample(frac=1) final baraja las filas para mezclar intenciones.
Esto nos da 180 mensajes, 15 por intención.
Paso 2: clasificar con la Decisions API
Una pregunta de tipo choice recibe un diccionario que asigna cada ID de opción a una descripción. Pasamos el mensaje como input y hacemos una única pregunta, con clave 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,}Con la tecnología de
La función decide_intent() envía un mensaje como input y una pregunta choice con nuestras 12 intenciones como opciones. Medimos el tiempo con time.perf_counter() y luego leemos la opción superior, la confianza, todas las probabilidades y los contadores de tokens de la respuesta.
Cada respuesta incluye tres campos:
choice: la opción con mayor probabilidad
probabilities: una probabilidad por opción, sumando 1
confidence: la probabilidad estimada de que la respuesta superior sea correcta
El objeto usage informa los tokens de entrada, y total_output_tokens siempre es 0.
Este es el resultado para el primer mensaje de nuestra muestra:
El modelo confundió dos intenciones similares, pero su confianza de 0,846 refleja cierta incertidumbre. Lo bueno es que la intención correcta, card_arrival, quedó segunda con casi toda la probabilidad restante (alrededor de 0,15). El resto de opciones, casi a cero.
Paso 3: clasificar con Flash-Lite
Para la línea base generativa, usamos salida estructurada con un enum de las mismas 12 etiquetas, así Flash-Lite solo puede devolver una etiqueta válida. También pedimos una confianza entre 0 y 1, que es como la mayoría de apps obtienen una puntuación de confianza de un modelo 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"],}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,}Con la tecnología de
La función generate_intent() construye un prompt con las 12 intenciones y sus descripciones. Llama a Flash-Lite con response_format establecido a nuestro esquema JSON, por lo que la salida debe ser JSON válido con una de las 12 etiquetas. La temperatura es 0 y el nivel de pensamiento minimal para mantener la respuesta estable y corta. Luego parseamos interaction.output_text con json.loads() y leemos los contadores de tokens de interaction.usage.
Probé el mismo mensaje del paso anterior con Flash-Lite y cometió el mismo error con mayor confianza:
Los thinking tokens son 0, lo que confirma que minimal limitó a Flash-Lite a escribir solo la respuesta. Flash-Lite usó menos tokens de entrada que Decision 1 (277 vs 337) porque la Decisions API cuenta las descripciones de las opciones dentro de la pregunta como entrada.
Paso 4: clasificar un mensaje por solicitud
Ahora, enviemos los 180 mensajes a ambos modelos, una solicitud cada vez, tras dos llamadas de calentamiento por modelo:
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"]Con la tecnología de
Este bucle envía cada mensaje a ambas funciones y guarda la predicción, la confianza, la latencia y los tokens como una fila. Luego convertimos las filas en un DataFrame y añadimos una columna correct que marca si cada predicción coincide con la etiqueta real.
Estos son los resultados:
Métrica
Gemini Decision 1
Gemini 3.5 Flash-Lite
Precisión
84,4%
83,9%
Latencia mediana
325 ms
1.068 ms
p90 de latencia
412 ms
6.483 ms
Solicitud más lenta
1,0 s
101,6 s
Solicitudes > 5 s
0 de 180
33 de 180
Media de tokens de entrada
339
279
Media de tokens de salida
0
25
Tres conclusiones que aprendimos de estas métricas:
Precisión: ambos modelos fueron igual de precisos, aproximadamente.
Latencia: Decision 1 fue ~3 veces más rápido en la mediana y mucho más consistente, mientras que Flash-Lite tuvo una cola larga de solicitudes lentas.
Tokens: Decision 1 usó más tokens de entrada porque las descripciones de opciones cuentan como entrada, pero no generó tokens de salida.
Nota: Nuestro cronometraje incluye el viaje de red desde Colab, así que considera esa diferencia como dependiente del entorno.
Paso 5: comprobar la calibración
La precisión indica con qué frecuencia acierta un modelo, pero la calibración nos dice si su confianza significa algo o no. Un modelo está bien calibrado cuando su confianza coincide con su precisión; es decir, si dice 0,8 en un grupo de respuestas, alrededor del 80% deberían ser correctas.
Para medirlo, agrupamos predicciones en 10 intervalos de confianza y comparamos la confianza media de cada uno con su precisión. El error de calibración esperado (ECE) es la media ponderada de las diferencias, según cuántas predicciones caen en cada intervalo. Cuanto menor, mejor.
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 totalCon la tecnología de
La función ece() coloca cada predicción en uno de 10 intervalos por su confianza (0–0,1; 0,1–0,2; etc.). Para cada intervalo, toma la diferencia entre la confianza media y la precisión, la pondera por la proporción de predicciones en ese intervalo y suma los resultados.
Así comparan ambos modelos:
Métrica
Gemini Decision 1
Gemini 3.5 Flash-Lite
Precisión
84,4%
83,9%
Confianza media
0,867
0,957
ECE
0,050
0,124
Confianza media cuando acierta
0,901
0,966
Confianza media cuando falla
0,686
0,912
Figura: diagramas de fiabilidad de ambos modelos
La confianza de Decision 1 está cerca de su precisión, con un ECE de 0,050. Además, es claramente menor cuando el modelo se equivoca (0,686) que cuando acierta (0,901).
Flash-Lite es sobreconfiado. Informa 0,957 de media mientras acierta el 83,9% de las veces. Usó solo 9 valores de confianza distintos en 180 respuestas, y 158 de ellas fueron 0,95 o más. Incluso sus respuestas erróneas promediaron 0,912. El número parece una probabilidad, pero es la estimación que el propio modelo escribe como texto.
La calibración importa cuando actúas según la puntuación. Un patrón habitual es aceptar respuestas por encima de un umbral de confianza y enviar el resto a un modelo de respaldo o a una persona:
Umbral
Decision 1: porcentaje conservado
Decision 1: precisión en conservados
Flash-Lite: porcentaje conservado
Flash-Lite: precisión en conservados
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, un umbral más alto funciona como esperas. Al 0,9, conserva el 63% de mensajes con un 95,6% de precisión. Con Flash-Lite, el umbral apenas ayuda porque la mayoría de sus errores también tienen alta confianza. La documentación oficial recomienda elegir umbral con ejemplos etiquetados de tu propio tráfico.
Paso 6: clasificar 100 mensajes en una solicitud
La Decisions API puede responder hasta 1.000 preguntas sobre una entrada compartida en una sola solicitud. Para probarlo, ponemos N mensajes de clientes en una entrada y hacemos una pregunta por mensaje.
Para Decision 1, eso significa N preguntas choice con claves de m1 a 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.usageCon la tecnología de
Aquí, la función build_batch() numera los primeros N mensajes y los une en una entrada compartida. Luego decide_batch() crea una pregunta choice por mensaje, con claves de m1 a mN, los envía en una sola solicitud y lee una respuesta por clave.
Para Flash-Lite, enviamos la misma entrada compartida con un esquema JSON que tiene N campos, cada uno limitado a 12 etiquetas. Cada N usa los mismos mensajes en ambos modelos y cada ajuste se ejecuta tres veces.
Preguntas por solicitud
Decision 1: latencia mediana
Flash-Lite: latencia mediana
Decision 1: tokens de entrada
Flash-Lite: tokens de entrada / salida
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
Falló
15.100
Falló
100
59.095 ms
Falló
30.309
Falló
Hasta 25 preguntas, la latencia mediana de Decision 1 se mantuvo por debajo de 550 ms. La mediana de Flash-Lite creció con N, de menos de 1 s con 1 a 5 preguntas a 2,75 s con 25, porque tiene que escribir cada respuesta como tokens de salida. Incluso con 50 preguntas, la mediana de Decision 1 fue 592 ms, aunque una de las tres ejecuciones tardó 70 s.
Dos puntos clave para reflexionar:
Flash-Lite falló con 50 y 100 preguntas: las filas "Falló" de la tabla anterior son el mismo error 400. Indica que el esquema "tiene demasiados estados para servir". Un esquema con 50 o más campos, cada uno limitado a 12 etiquetas, supera lo que acepta el API.
Decision 1 se ralentizó con 100 preguntas: cada pregunta repite las 12 descripciones de opciones, unos 300 tokens por pregunta, por lo que la solicitud alcanzó 30.309 tokens, mientras que la promesa de latencia plana de Google cubre contextos hasta 16K tokens.
Paso 7: recortar las solicitudes
Ahora surge una pregunta obvia: ¿podemos evitar la ralentización y los fallos? Para Decision 1, usamos descripciones de opciones vacías (""). Para Flash-Lite, pedimos una única lista de N etiquetas en lugar de N campos separados:
# Decision 1: solo IDs de opción, sin descripciones"criteria":{k:""for k in LABELS}# Flash-Lite: un campo lista en lugar de N campos
schema ={"type":"object","properties":{"intents":{"type":"array","items":{"type":"string","enum": LABELS},"minItems": n,"maxItems": n,}},"required":["intents"],}Con la tecnología de
Así le fue a Decision 1 con descripciones vacías:
Preguntas por solicitud
Latencia mediana
Precisión
Tokens de entrada
25
357 ms
84,0%
3.995
50
649 ms
78,0%
7.950
100
1.603 ms
83,0%
16.009
Eliminar las descripciones redujo aproximadamente a la mitad los tokens de entrada. Con 100 preguntas, la solicitud bajó a ~16K tokens y la latencia mediana cayó de 59 s a 1,6 s. La precisión bajó un poco con 25 y 50 preguntas, así que descripciones cortas son un mejor punto medio que ninguna, sobre todo para intenciones similares.
El esquema de lista no ayudó al modelo Flash-Lite. Funcionó con 25 preguntas, pero siguió fallando con 50 y 100.
Paso 8: comparar el coste
Por último, calculamos el coste a partir de los contadores de tokens que devuelve cada API, usando precios del nivel de pago:
Modelo
Precio de entrada por 1M tokens
Precio de salida por 1M tokens
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (incluye thinking tokens)
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)/1e6Con la tecnología de
La función cost_per_request() multiplica cada contador de tokens por su precio por 1M de tokens. En Decision 1 solo cuentan los tokens de entrada. En Flash-Lite, los thinking tokens se facturan al precio de salida, así que los sumamos a los de salida.
Este es el coste por 1.000 solicitudes en cada configuración:
Configuración
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 mensaje por solicitud
$0,034
$0,147
4,3x
5 preguntas por solicitud
$0,155
$0,271
1,7x
10 preguntas por solicitud
$0,306
$0,459
1,5x
25 preguntas por solicitud
$0,757
$1,088
1,4x
25 preguntas, configuraciones recortadas (Paso 7)
$0,400
$0,831
2,1x
50 preguntas por solicitud
$1,510
Falló
n/a
100 preguntas, descripciones vacías
$1,601
Falló
n/a
En mensajes individuales, Decision 1 fue 4,3x más barato, pero la diferencia se reduce al agrupar más preguntas en una solicitud. La entrada compartida se factura una vez en ambas APIs. Pero cada pregunta de Decision 1 arrastra su propia instrucción y las 12 descripciones, mientras que Flash-Lite ve la lista de etiquetas una sola vez y paga una salida corta por respuesta. Con 25 preguntas, Decision 1 usó 7.570 tokens de entrada frente a 710 de entrada y 350 de salida de Flash-Lite.
Nota: La Decisions API no admite caché de contexto ni Batch API. Si envías la misma entrada en varias solicitudes, se factura completa cada vez. Así que, si tienes muchas preguntas sobre la misma entrada, hazlas en una sola solicitud en lugar de repartirlas.
Cuándo usar cada enfoque
Según lo anterior, un modelo de decisiones encaja mejor cuando:
La respuesta sale de un conjunto fijo de opciones, como intenciones, rutas, herramientas o etiquetas de políticas
La decisión va en la ruta de petición, donde cada persona usuaria espera a que termine
Quieres actuar según la confianza, por ejemplo, enviando los casos dudosos a un fallback o a una persona
Necesitas hacer muchas comprobaciones independientes sobre la misma entrada en una sola solicitud
Un modelo generativo sigue siendo mejor cuando:
Necesitas una explicación, un valor extraído o texto libre
El conjunto de posibles respuestas es abierto o cambia por solicitud
Ya hiciste una llamada generativa sobre esa entrada y puedes añadir la clasificación a ella
Usa la Decisions API cuando necesites
Usa la Interactions API cuando necesites
Una probabilidad sí/no, una opción de un conjunto fijo o una puntuación en una escala fija
Texto generado, resúmenes o explicaciones
Probabilidades calibradas que puedas umbralizar
Valores u objetos extraídos que sigan tu propio esquema JSON
Muchas comprobaciones independientes sobre la misma entrada en una llamada
Llamadas a herramientas con argumentos
Baja latencia y coste cero en tokens de salida
Razonamiento en varios pasos
Conclusiones
En este tutorial, construimos un clasificador de intenciones bancarias con Gemini Decision 1 y Gemini 3.5 Flash-Lite, y comparamos ambos modelos en precisión, latencia, calibración y coste. Cuatro ideas clave:
Empate en precisión: 84,4% para Decision 1 y 83,9% para Flash-Lite, con el mismo veredicto en 163 de 180 mensajes.
Decision 1 fue más rápido y predecible: latencia mediana de 325 ms frente a 1.068 ms, y la solicitud más lenta tardó 1,0 s frente a 101,6 s.
La confianza de Decision 1 fue utilizable: su ECE fue 0,050 frente a 0,124, y subir el umbral a 0,9 elevó la precisión en respuestas conservadas del 84,4% al 95,6%. La confianza autoinformada de Flash-Lite apenas separó aciertos de errores.
El coste y el escalado dependen de cómo plantees las preguntas: Decision 1 fue 4,3x más barato en mensajes sueltos, pero cada pregunta paga por sus descripciones de opción. Mantén el total de entrada por debajo de ~16K tokens y deja las descripciones lo más cortas posible.
Estos resultados salen de una tarea, un dataset y pocas ejecuciones desde un cuaderno de Colab. Tómalos como observaciones de una demo, no como afirmaciones generales de rendimiento.
Soy experta Google Developers en ML (Gen AI), triple experta en Kaggle y embajadora de Women Techmakers, con más de tres años de experiencia en el sector tecnológico. Cofundé una startup de salud en 2020 y actualmente curso un máster en informática en Georgia Tech, con especialización en aprendizaje automático.
FAQs
¿Cuál es la diferencia entre la Decisions API y una API generativa?⌄
Una API generativa escribe su respuesta token a token y factura cada token de salida. La Decisions API puntúa un conjunto fijo de opciones en una sola pasada y devuelve una probabilidad por cada una. No genera tokens de salida, así que solo pagas la entrada.
¿Es Gemini Decision 1 más preciso que Gemini 3.5 Flash-Lite?⌄
No en nuestra prueba. En 180 mensajes bancarios, la precisión fue del 84,4% para Decision 1 y del 83,9% para Flash-Lite. Las diferencias estuvieron en latencia, calibración y coste.
¿Por qué Decision 1 usa más tokens de entrada que Flash-Lite?⌄
Las instrucciones de cada pregunta y las descripciones de opciones cuentan como entrada. Con 12 opciones descritas, añadieron unos 300 tokens por pregunta en nuestra prueba. Descripciones cortas o vacías lo reducen.
¿La latencia se mantiene plana al añadir más preguntas?⌄
En nuestras ejecuciones, la mediana se mantuvo por debajo de 650 ms hasta 50 preguntas. Con 100 preguntas y descripciones completas, la solicitud llegó a ~30K tokens y tardó de 48 a 59 s. Con descripciones vacías, las mismas 100 preguntas entraron en ~16K tokens y tardaron 1,6 s.
¿Qué tipos de pregunta admite la Decisions API?⌄
Decisions API admite tres tipos de preguntas: noul para comprobaciones sí/no, choice para elegir una opción entre 2 y 255, y score para puntuar según una rúbrica ordenada. Puedes combinar las tres en una sola solicitud.
Alternativas de código abierto a GPT-4 que pueden ofrecer un rendimiento similar y requieren menos recursos informáticos para funcionar. Estos proyectos vienen con instrucciones, fuentes de código, pesos del modelo, conjuntos de datos e IU de chatbot.
Descubre cómo los modelos lingüísticos de IA como ChatGPT pueden revolucionar tus operaciones financieras, desde la generación de informes hasta la traducción de jerga financiera.
Aprende a utilizar modelos de IA generativa para crear un editor de imágenes, un chatbot similar a ChatGPT con pocos recursos y una aplicación clasificadora de aprobación de préstamos y a automatizar interacciones PDF y un asistente de voz con GPT.
Explore GPT-3.5 Turbo y descubra el potencial transformador del ajuste fino. Aprenda a personalizar este modelo de lenguaje avanzado para aplicaciones especializadas, mejore su rendimiento y comprenda los costes asociados, la seguridad y las consideraciones de privacidad.
DeepSeek-Coder-V2 es un modelo de lenguaje de código de código abierto que rivaliza con el rendimiento de GPT-4, Gemini 1.5 Pro, Claude 3 Opus, Llama 3 70B o Codestral.
Libere todo el potencial de GPT-3 mediante el ajuste fino. Aprenda a utilizar la API de OpenAI y Python para mejorar este modelo de red neuronal avanzado para su caso de uso específico.
Domina Gemini y NotebookLM para automatizar tareas, aumentar la productividad y trabajar de forma más inteligente en todo el ecosistema de IA de Google.
Analyze data smarter with Gemini in Google Sheets. Use AI-powered insights, formula suggestions, and automation to simplify spreadsheets and boost productivity.
La mayoría de las apps con LLM están llenas de microdecisiones: ¿qué herramienta debe llamar el agente?, ¿qué modelo debe gestionar esta consulta?, ¿este mensaje incumple alguna política?
Hoy, muchos equipos responden a estas preguntas pidiéndole a un modelo generativo que escriba la respuesta como texto y luego parsean ese texto para tomar una decisión.
La Gemini Decisions API de Google propone otro enfoque. Usa el modelo Gemini Decision 1 para puntuar un conjunto fijo de opciones en una sola pasada y devuelve una probabilidad para cada opción, sin facturar tokens de salida.
En este tutorial, ejecutaremos la misma tarea de clasificación de intenciones con dos configuraciones:
Los compararemos en precisión, latencia, uso de tokens, coste y calibración, y luego pasaremos de 1 a 100 preguntas en una sola solicitud.
Al final del tutorial, sabrás cómo:
Llamar a la Decisions API con preguntas
choicey leer sus probabilidades y puntuaciones de confianzaCrear una línea base generativa con la Interactions API y un esquema JSON
Medir la latencia, el uso de tokens y el coste en ambos enfoques
Comprobar si la confianza de un modelo es fiable con un diagrama de fiabilidad y el error de calibración esperado (ECE)
Decidir cuándo un modelo de decisiones encaja mejor en tu app que uno generativo
Puedes ejecutar el código completo en este Google Colab.
Modelos de decisión vs. modelos generativos
Antes de ver cómo funciona cada uno, definamos ambos términos.
Aquí tienes un ejemplo.
Una clienta escribe a un banco: "Mi tarjeta aún no ha llegado. ¿Cuándo llegará?"
Si le preguntas a un modelo generativo: "¿Qué quiere esta clienta?", podría responder:
«La clienta está esperando una tarjeta nueva y quiere saber cuándo llegará».
Es una buena respuesta para que la lea una persona. Pero si tu app necesita enrutar el mensaje al equipo adecuado, tu código tiene que convertir esa frase en una etiqueta. Puedes forzar una etiqueta con un esquema JSON, pero el modelo seguirá "escribiéndola" token a token.
En cambio, si preguntas lo mismo a un modelo de decisiones, primero le pasas las opciones, por ejemplo
card_arrival,lost_or_stolen_cardyexchange_rate. Devuelve una probabilidad por cada una:Tu código puede actuar directamente sobre esa probabilidad: enrutar al equipo de tarjetas si
card_arrivalsupera un umbral y mandarlo a una persona si no. En resumen:Modelo generativo
Modelo de decisiones
Devuelve
Texto que escribe
Una probabilidad por cada opción que defines
Respuestas posibles
Abiertas
Conjunto fijo
Bueno para
Respuestas, resúmenes, explicaciones y extracción
Enrutado, selección de herramientas, comprobaciones de políticas y evaluación
En la práctica, muchas apps usan un modelo generativo para ambos trabajos. Eso es lo que probaremos a continuación: si un modelo de decisiones hace mejor la parte de clasificación que uno generativo.
Cuando usas un modelo generativo como clasificador, escribe la respuesta token a token. Para una respuesta JSON como la nuestra, la salida va generándose así:
Cada token es un paso de decodificación distinto y cada token de salida se factura. Si quieres una puntuación de confianza, el modelo también tiene que escribir ese número. Ese número es la propia estimación del modelo sobre sí mismo, no una probabilidad medida en sus internos.
Un modelo de decisiones, en cambio, se salta la fase de escritura. Le das las opciones por adelantado y puntúa todas frente a la entrada en una pasada. El resultado es una probabilidad para cada opción:
Esto cambia tres cosas que puedes medir:
La contrapartida es que solo puedes hacer preguntas de conjunto cerrado. Un modelo de decisiones no puede explicar su respuesta, extraer un valor ni escribir texto libre.
Demo: crear un clasificador de intenciones bancarias
En esta demo, construiremos un clasificador de intenciones bancarias. Usaremos la partición de test de Banking77, un dataset público de mensajes de clientes etiquetados con 77 intenciones, y nos quedaremos con 12 intenciones fáciles de confundir entre sí:
card_arrivalycard_delivery_estimatepending_card_payment,declined_card_paymentycard_payment_fee_chargedpending_transfer,transfer_not_received_by_recipientybalance_not_updated_after_bank_transferlost_or_stolen_card,card_not_working,exchange_rateytop_up_failedIntenciones similares hacen la tarea más difícil, lo que vuelve más interesante analizar las puntuaciones de confianza.
Ejecutaremos el clasificador con ambos modelos de dos formas:
Estos son los ajustes que mantenemos iguales en ambos modelos:
Ajuste
Valor usado
Por qué
Modelo de decisiones
gemini-decision-1El modelo bajo prueba
Modelo generativo
gemini-3.5-flash-liteLa línea base generativa rentable usada en el post de lanzamiento
Temperatura de Flash-Lite
0.0
Elimina el ruido de muestreo de la línea base
Nivel de pensamiento de Flash-Lite
minimalMantiene la comparación en la decodificación, no en el razonamiento
Formato de salida
Esquema JSON con un
enumde las 12 etiquetasFlash-Lite solo puede devolver una etiqueta válida
Descripciones de opciones
Una frase corta por intención
Ambos modelos ven las mismas definiciones de etiquetas
Llamadas de calentamiento
2 por modelo
Saca la configuración de conexión de las medidas
Repeticiones (muchas preguntas por solicitud)
3 por ajuste
Reportamos la mediana, no una sola ejecución
Nota: Son ajustes funcionales para esta demo, no configuraciones afinadas para ninguno de los modelos.
Paso 1: requisitos previos y configuración
Para seguir el tutorial, necesitas:
Una clave de la Gemini API desde Google AI Studio
Un cuaderno de Colab (o cualquier entorno de Python 3)
google-genaiversión 3.2 o posteriorLa Decisions API tiene un nivel sin coste en Google AI Studio para prototipado, así que puedes probarla antes de pagar. Yo ejecuté esta demo en Colab, pero usa cualquier entorno Python 3 que prefieras.
Empecemos instalando los paquetes:
Aquí,
google-genaies el SDK de Google en Python para la Gemini API. Nos da los métodosclient.decisions.createyclient.interactions.create, que envían solicitudes a la Decisions API y a la Interactions API. Usamospandaspara cargar el dataset y organizar resultados, ymatplotlibpara representar las figuras.Después creamos el cliente. La Decisions API necesita la versión v1beta del API:
Aquí,
genai.Client()lee la clave de API deGEMINI_API_KEYdefinida en los secretos de Colab o como variable de entorno, yhttp_optionsla dirige al API v1beta, donde está la Decisions API.Luego cargaremos el dataset Banking77 y definiremos nuestras 12 intenciones. Cada intención tiene una descripción de una frase que verán ambos modelos:
El fragmento anterior descarga la partición de test de Banking77 como CSV y mantiene solo las filas con una de nuestras 12 intenciones. Luego toma 15 mensajes por intención con una semilla fija para reproducibilidad. El
.sample(frac=1)final baraja las filas para mezclar intenciones.Esto nos da 180 mensajes, 15 por intención.
Paso 2: clasificar con la Decisions API
Una pregunta de tipo
choicerecibe un diccionario que asigna cada ID de opción a una descripción. Pasamos el mensaje comoinputy hacemos una única pregunta, con claveintent:La función
decide_intent()envía un mensaje comoinputy una preguntachoicecon nuestras 12 intenciones como opciones. Medimos el tiempo contime.perf_counter()y luego leemos la opción superior, la confianza, todas las probabilidades y los contadores de tokens de la respuesta.Cada respuesta incluye tres campos:
choice: la opción con mayor probabilidadprobabilities: una probabilidad por opción, sumando 1confidence: la probabilidad estimada de que la respuesta superior sea correctaEl objeto
usageinforma los tokens de entrada, ytotal_output_tokenssiempre es 0.Este es el resultado para el primer mensaje de nuestra muestra:
El modelo confundió dos intenciones similares, pero su confianza de 0,846 refleja cierta incertidumbre. Lo bueno es que la intención correcta,
card_arrival, quedó segunda con casi toda la probabilidad restante (alrededor de 0,15). El resto de opciones, casi a cero.Paso 3: clasificar con Flash-Lite
Para la línea base generativa, usamos salida estructurada con un
enumde las mismas 12 etiquetas, así Flash-Lite solo puede devolver una etiqueta válida. También pedimos una confianza entre 0 y 1, que es como la mayoría de apps obtienen una puntuación de confianza de un modelo generativo:La función
generate_intent()construye un prompt con las 12 intenciones y sus descripciones. Llama a Flash-Lite conresponse_formatestablecido a nuestro esquema JSON, por lo que la salida debe ser JSON válido con una de las 12 etiquetas. La temperatura es0y el nivel de pensamientominimalpara mantener la respuesta estable y corta. Luego parseamosinteraction.output_textconjson.loads()y leemos los contadores de tokens deinteraction.usage.Probé el mismo mensaje del paso anterior con Flash-Lite y cometió el mismo error con mayor confianza:
Los thinking tokens son 0, lo que confirma que
minimallimitó a Flash-Lite a escribir solo la respuesta. Flash-Lite usó menos tokens de entrada que Decision 1 (277 vs 337) porque la Decisions API cuenta las descripciones de las opciones dentro de la pregunta como entrada.Paso 4: clasificar un mensaje por solicitud
Ahora, enviemos los 180 mensajes a ambos modelos, una solicitud cada vez, tras dos llamadas de calentamiento por modelo:
Este bucle envía cada mensaje a ambas funciones y guarda la predicción, la confianza, la latencia y los tokens como una fila. Luego convertimos las filas en un DataFrame y añadimos una columna
correctque marca si cada predicción coincide con la etiqueta real.Estos son los resultados:
Métrica
Gemini Decision 1
Gemini 3.5 Flash-Lite
Precisión
84,4%
83,9%
Latencia mediana
325 ms
1.068 ms
p90 de latencia
412 ms
6.483 ms
Solicitud más lenta
1,0 s
101,6 s
Solicitudes > 5 s
0 de 180
33 de 180
Media de tokens de entrada
339
279
Media de tokens de salida
0
25
Tres conclusiones que aprendimos de estas métricas:
Nota: Nuestro cronometraje incluye el viaje de red desde Colab, así que considera esa diferencia como dependiente del entorno.
Paso 5: comprobar la calibración
La precisión indica con qué frecuencia acierta un modelo, pero la calibración nos dice si su confianza significa algo o no. Un modelo está bien calibrado cuando su confianza coincide con su precisión; es decir, si dice 0,8 en un grupo de respuestas, alrededor del 80% deberían ser correctas.
Para medirlo, agrupamos predicciones en 10 intervalos de confianza y comparamos la confianza media de cada uno con su precisión. El error de calibración esperado (ECE) es la media ponderada de las diferencias, según cuántas predicciones caen en cada intervalo. Cuanto menor, mejor.
La función
ece()coloca cada predicción en uno de 10 intervalos por su confianza (0–0,1; 0,1–0,2; etc.). Para cada intervalo, toma la diferencia entre la confianza media y la precisión, la pondera por la proporción de predicciones en ese intervalo y suma los resultados.Así comparan ambos modelos:
Métrica
Gemini Decision 1
Gemini 3.5 Flash-Lite
Precisión
84,4%
83,9%
Confianza media
0,867
0,957
ECE
0,050
0,124
Confianza media cuando acierta
0,901
0,966
Confianza media cuando falla
0,686
0,912
Figura: diagramas de fiabilidad de ambos modelos
La confianza de Decision 1 está cerca de su precisión, con un ECE de 0,050. Además, es claramente menor cuando el modelo se equivoca (0,686) que cuando acierta (0,901).
Flash-Lite es sobreconfiado. Informa 0,957 de media mientras acierta el 83,9% de las veces. Usó solo 9 valores de confianza distintos en 180 respuestas, y 158 de ellas fueron 0,95 o más. Incluso sus respuestas erróneas promediaron 0,912. El número parece una probabilidad, pero es la estimación que el propio modelo escribe como texto.
La calibración importa cuando actúas según la puntuación. Un patrón habitual es aceptar respuestas por encima de un umbral de confianza y enviar el resto a un modelo de respaldo o a una persona:
Umbral
Decision 1: porcentaje conservado
Decision 1: precisión en conservados
Flash-Lite: porcentaje conservado
Flash-Lite: precisión en conservados
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, un umbral más alto funciona como esperas. Al 0,9, conserva el 63% de mensajes con un 95,6% de precisión. Con Flash-Lite, el umbral apenas ayuda porque la mayoría de sus errores también tienen alta confianza. La documentación oficial recomienda elegir umbral con ejemplos etiquetados de tu propio tráfico.
Paso 6: clasificar 100 mensajes en una solicitud
La Decisions API puede responder hasta 1.000 preguntas sobre una entrada compartida en una sola solicitud. Para probarlo, ponemos N mensajes de clientes en una entrada y hacemos una pregunta por mensaje.
Para Decision 1, eso significa N preguntas
choicecon claves dem1amN:Aquí, la función
build_batch()numera los primeros N mensajes y los une en una entrada compartida. Luegodecide_batch()crea una preguntachoicepor mensaje, con claves dem1amN, los envía en una sola solicitud y lee una respuesta por clave.Para Flash-Lite, enviamos la misma entrada compartida con un esquema JSON que tiene N campos, cada uno limitado a 12 etiquetas. Cada N usa los mismos mensajes en ambos modelos y cada ajuste se ejecuta tres veces.
Preguntas por solicitud
Decision 1: latencia mediana
Flash-Lite: latencia mediana
Decision 1: tokens de entrada
Flash-Lite: tokens de entrada / salida
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
Falló
15.100
Falló
100
59.095 ms
Falló
30.309
Falló
Hasta 25 preguntas, la latencia mediana de Decision 1 se mantuvo por debajo de 550 ms. La mediana de Flash-Lite creció con N, de menos de 1 s con 1 a 5 preguntas a 2,75 s con 25, porque tiene que escribir cada respuesta como tokens de salida. Incluso con 50 preguntas, la mediana de Decision 1 fue 592 ms, aunque una de las tres ejecuciones tardó 70 s.
Dos puntos clave para reflexionar:
Paso 7: recortar las solicitudes
Ahora surge una pregunta obvia: ¿podemos evitar la ralentización y los fallos? Para Decision 1, usamos descripciones de opciones vacías (""). Para Flash-Lite, pedimos una única lista de N etiquetas en lugar de N campos separados:
Así le fue a Decision 1 con descripciones vacías:
Preguntas por solicitud
Latencia mediana
Precisión
Tokens de entrada
25
357 ms
84,0%
3.995
50
649 ms
78,0%
7.950
100
1.603 ms
83,0%
16.009
Eliminar las descripciones redujo aproximadamente a la mitad los tokens de entrada. Con 100 preguntas, la solicitud bajó a ~16K tokens y la latencia mediana cayó de 59 s a 1,6 s. La precisión bajó un poco con 25 y 50 preguntas, así que descripciones cortas son un mejor punto medio que ninguna, sobre todo para intenciones similares.
El esquema de lista no ayudó al modelo Flash-Lite. Funcionó con 25 preguntas, pero siguió fallando con 50 y 100.
Paso 8: comparar el coste
Por último, calculamos el coste a partir de los contadores de tokens que devuelve cada API, usando precios del nivel de pago:
Modelo
Precio de entrada por 1M tokens
Precio de salida por 1M tokens
Gemini Decision 1
$0,10
$0
Gemini 3.5 Flash-Lite
$0,30
$2,50 (incluye thinking tokens)
La función
cost_per_request()multiplica cada contador de tokens por su precio por 1M de tokens. En Decision 1 solo cuentan los tokens de entrada. En Flash-Lite, los thinking tokens se facturan al precio de salida, así que los sumamos a los de salida.Este es el coste por 1.000 solicitudes en cada configuración:
Configuración
Gemini Decision 1
Gemini 3.5 Flash-Lite
Flash-Lite / Decision 1
1 mensaje por solicitud
$0,034
$0,147
4,3x
5 preguntas por solicitud
$0,155
$0,271
1,7x
10 preguntas por solicitud
$0,306
$0,459
1,5x
25 preguntas por solicitud
$0,757
$1,088
1,4x
25 preguntas, configuraciones recortadas (Paso 7)
$0,400
$0,831
2,1x
50 preguntas por solicitud
$1,510
Falló
n/a
100 preguntas, descripciones vacías
$1,601
Falló
n/a
En mensajes individuales, Decision 1 fue 4,3x más barato, pero la diferencia se reduce al agrupar más preguntas en una solicitud. La entrada compartida se factura una vez en ambas APIs. Pero cada pregunta de Decision 1 arrastra su propia instrucción y las 12 descripciones, mientras que Flash-Lite ve la lista de etiquetas una sola vez y paga una salida corta por respuesta. Con 25 preguntas, Decision 1 usó 7.570 tokens de entrada frente a 710 de entrada y 350 de salida de Flash-Lite.
Nota: La Decisions API no admite caché de contexto ni Batch API. Si envías la misma entrada en varias solicitudes, se factura completa cada vez. Así que, si tienes muchas preguntas sobre la misma entrada, hazlas en una sola solicitud en lugar de repartirlas.
Cuándo usar cada enfoque
Según lo anterior, un modelo de decisiones encaja mejor cuando:
Un modelo generativo sigue siendo mejor cuando:
Usa la Decisions API cuando necesites
Usa la Interactions API cuando necesites
Una probabilidad sí/no, una opción de un conjunto fijo o una puntuación en una escala fija
Texto generado, resúmenes o explicaciones
Probabilidades calibradas que puedas umbralizar
Valores u objetos extraídos que sigan tu propio esquema JSON
Muchas comprobaciones independientes sobre la misma entrada en una llamada
Llamadas a herramientas con argumentos
Baja latencia y coste cero en tokens de salida
Razonamiento en varios pasos
Conclusiones
En este tutorial, construimos un clasificador de intenciones bancarias con Gemini Decision 1 y Gemini 3.5 Flash-Lite, y comparamos ambos modelos en precisión, latencia, calibración y coste. Cuatro ideas clave:
Estos resultados salen de una tarea, un dataset y pocas ejecuciones desde un cuaderno de Colab. Tómalos como observaciones de una demo, no como afirmaciones generales de rendimiento.