Перейти к основному содержимому

Gemini Decisions API: тестирование новой модели решений от Google на задержке и стоимости

Узнайте, как Gemini Decision 1 оценивает фиксированные опции без генерации текста, создайте классификатор намерений с Decisions API и сравните его с Gemini 3.5 Flash-Lite по точности, задержке, калибровке и стоимости.
· 15 мин читать

Исследуйте с ИИ

Большинство приложений на базе LLM строятся из множества мелких решений: Какой инструмент должен вызвать агент? Какой модели поручить этот запрос? Нарушает ли это сообщение политику?

Сегодня многие команды отвечают на эти вопросы, прося генеративную модель записать ответ в виде текста, а затем парсят этот текст, чтобы принять решение.

Google's Gemini Decisions API предлагает другой подход. Он использует модель Gemini Decision 1, чтобы оценить фиксированный набор опций за один прямой проход и вернуть вероятность для каждой опции при нулевой тарификации выходных токенов.

В этом руководстве мы выполним одну и ту же задачу классификации намерений в двух конфигурациях:

  • Gemini Decision 1 через Decisions API
  • Gemini 3.5 Flash-Lite через Interactions API, со структурированным JSON-выводом

Мы сравним их по точности, задержке, использованию токенов, стоимости и калибровке, а затем увеличим нагрузку с 1 до 100 вопросов в одном запросе.

К концу этого руководства вы узнаете, как:

  • Вызывать Decisions API с вопросами типа choice и читать его вероятности и оценки уверенности

  • Построить генеративный бейзлайн с Interactions API и JSON-схемой

  • Измерять задержку, использование токенов и стоимость для обоих подходов

  • Проверять, можно ли доверять уверенности модели, с помощью диаграммы надёжности и ожидаемой ошибки калибровки (ECE)

  • Решать, когда модель решений лучше подходит вашему приложению, чем генеративная

Весь код можно запустить в этом Google Colab.

Модели решений vs. генеративные модели

Прежде чем разбирать, как каждая из них работает, определим термины.

  • Генеративная модель: генерирует новый контент. Вы даёте ей промпт, и она пишет ответ по одному токену. Это может быть ответ, краткое изложение, код или метка. Gemini 3.5 Flash-Lite, как и большинство LLM, используемых в чат-приложениях, — генеративная модель.
  • Модель решений: выбирает из заданных вами опций. Вы даёте ей ввод и фиксированный список возможных ответов, а она возвращает вероятность для каждой опции, не записывая ни строчки текста. Gemini Decision 1 — это модель решений.

Вот пример. 

Клиент пишет в банк: "Моя карта ещё не пришла. Когда она будет?"

Если спросить у генеративной модели, "Чего хочет этот клиент?", она может ответить:

«Клиент ждёт новую карту и хочет узнать, когда она придёт».

Это хороший ответ для человека. Но если вашему приложению нужно направить сообщение в нужную команду, теперь коду придётся преобразовать это предложение в метку. Можно принудительно получить метку с помощью JSON-схемы, но модель всё равно записывает её токен за токеном.

Если же задать тот же вопрос модели решений, вы сначала даёте ей варианты, например card_arrival, lost_or_stolen_card и exchange_rate. Она возвращает вероятность для каждого:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Далее ваш код может действовать напрямую по этой вероятности: маршрутизировать к команде по картам, если card_arrival выше порога, и отправлять человеку, если нет. Вкратце:

 

Генеративная модель

Модель решений

Что возвращает

Текст, который она пишет

Вероятность для каждой заданной опции

Возможные ответы

Открытый множества

Фиксированный набор

Подходит для

Ответов, саммари, объяснений и извлечения данных

Маршрутизации, выбора инструмента, проверок политики и оценивания

На практике многие приложения используют генеративную модель для обеих задач. Именно это мы и проверим в следующем разделе: делает ли модель решений классификацию лучше, чем генеративная модель.

Когда вы используете генеративную модель как классификатор, она записывает ответ по одному токену. Для нашего JSON-ответа это выглядит так по мере генерации:

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

Каждый токен — отдельный шаг декодирования, и каждый выходной токен тарифицируется. Если вам нужен показатель уверенности, модель должна записать это число тоже. Это число — собственная оценка модели о себе, а не вероятность, полученная из её внутренних вычислений.

Модель решений, напротив, пропускает этап записи. Вы заранее передаёте опции, и она оценивает их все относительно ввода за один прямой проход. Результат — вероятность для каждой опции:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Это меняет три измеряемые вещи:

  • Задержка: Нет цикла декодирования, поэтому задержка не должна расти с длиной ответа.
  • Стоимость: Нет выходных токенов для тарификации. Вы платите только за входные токены, в которые входят текст вопроса и описания опций.
  • Уверенность: Уверенность исходит из самих вероятностей, поэтому она должна соответствовать частоте правильных ответов модели.

Компромисс в том, что можно задавать только вопросы с закрытым набором ответов. Модель решений не сможет объяснить свой ответ, извлечь значение или написать свободный текст.

Демо: строим классификатор банковских намерений

В этом демо мы построим классификатор намерений для банковских сообщений. Используем тестовый сплит Banking77 — публичного датасета клиентских сообщений с 77 намерениями — и оставим 12 намерений, которые легко перепутать:

  • card_arrival и card_delivery_estimate

  • pending_card_payment, declined_card_payment и card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient и balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate и top_up_failed

Похожие намерения усложняют задачу, а значит, интереснее изучать метрики уверенности.

Запустим классификатор на обеих моделях двумя способами:

  • Одно сообщение на запрос: 180 сообщений (по 15 на намерение), отправленных в каждую модель по одному.
  • Много вопросов в запросе: N сообщений в общем вводе, по одному вопросу на сообщение, для N = 1, 5, 10, 25, 50 и 100.

Вот настройки, которые одинаковы для обеих модельs:

Параметр

Используемое значение

Почему 

Модель решений

gemini-decision-1

Тестируемая модель

Генеративная модель

gemini-3.5-flash-lite

Экономичный генеративный бейзлайн, использованный в сравнении анонса

Температура Flash-Lite

0.0

Убирает шум сэмплирования из бейзлайна

Уровень размышлений Flash-Lite

minimal

Сохраняет сравнение про декодирование, а не про рассуждения

Формат вывода

JSON-схема с enum из 12 меток

Flash-Lite может вернуть только валидную метку

Описания опций

По одному короткому предложению на намерение

Обе модели видят одинаковые определения меток

Прогревочные вызовы

2 на модель

Исключает установку соединения из измерений

Повторы (много вопросов на запрос)

3 на настройку

Мы берём медиану, а не один прогон

Примечание: Это рабочие настройки для демо, а не тюнинг-параметры для какой-либо модели.

Шаг 1. Требования и настройка

Чтобы повторить шаги, вам понадобится:

  • Ключ API Gemini из Google AI Studio

  • Ноутбук Colab (или любая среда Python 3)

  • google-genai версии 3.2 или новее

В Google AI Studio у Decisions API есть бесплатный тариф для прототипирования, так что можно попробовать до оплаты. Это демо запускалось в Colab, но можно использовать и любую среду Python 3. 

Начнём с установки пакетов:

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

Здесь google-genai — Python SDK Google для Gemini API. Он даёт методы client.decisions.create и client.interactions.create для отправки запросов в Decisions API и Interactions API. Мы используем pandas для загрузки датасета и организации результатов, а matplotlib — для построения графиков.

Далее создадим клиент. Decisions 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"

Здесь genai.Client() читает ключ API из GEMINI_API_KEY, заданного в секретах Colab или как переменная окружения, а http_options указывает версию v1beta, где доступен Decisions API. 

Затем загрузим датасет Banking77 и определим наши 12 намерений. Каждое намерение получает однострочное описание, которое увидят обе модели:

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

Этот фрагмент кода скачивает тестовый сплит Banking77 в формате CSV и оставляет только строки с одной из наших 12 меток. Затем он отбирает по 15 сообщений на каждое намерение с фиксированным зерном случайности, чтобы выборка была воспроизводимой. Финальный .sample(frac=1) перемешивает строки, чтобы перемешать намерения.

Итого получаем 180 сообщений, по 15 на намерение.

Шаг 2. Классификация через Decisions API

Вопрос типа choice принимает словарь, сопоставляющий каждому ID опции её описание. Мы передаём сообщение как input и задаём один вопрос с ключом intent:

def decide_intent(text):
    start = time.perf_counter()
    result = client.decisions.create(
        model=DECISION_MODEL,
        input=text,
        questions={
            "intent": {
                "type": "choice",
                "instructions": "Which intent best describes this banking customer message?",
                "criteria": INTENTS,
            }
        },
    )
    latency = time.perf_counter() - start
    ans = result.answers["intent"]
    return {
        "pred": ans.choice,
        "confidence": float(ans.confidence),
        "probabilities": dict(ans.probabilities),
        "latency_s": latency,
        "input_tokens": result.usage.total_input_tokens,
        "output_tokens": result.usage.total_output_tokens,
    }

Функция decide_intent() отправляет одно сообщение во input и один вопрос choice с нашими 12 намерениями как опциями. Мы замеряем время вызова через time.perf_counter(), затем читаем верхний выбор, уверенность, вероятности всех опций и количество токенов из ответа.

Каждый ответ содержит три поля:

  • choice: опция с наивысшей вероятностью

  • probabilities: по одной вероятности на опцию, сумма равна 1

  • confidence: оценка вероятности того, что верхний ответ верный

Объект usage сообщает о входных токенах, а total_output_tokens всегда равен 0.

Вот результат для первого сообщения нашей выборки:

Модель перепутала два похожих намерения, но уверенность 0.846 показывает некоторую неопределённость. Хорошо то, что правильное намерение, card_arrival, оказалось вторым с почти всей оставшейся вероятностью (около 0.15). Все остальные опции были близки к нулю.

Шаг 3. Классификация во Flash-Lite

Для генеративного бейзлайна используем структурированный вывод с enum из тех же 12 меток, чтобы Flash-Lite мог вернуть только валидную метку. Мы также просим уверенность от 0 до 1 — так большинство приложений получают уверенность от генеративной модели:

LABEL_LIST = "\n".join(f"- {k}: {v}" for k, v in INTENTS.items())

GEN_SCHEMA = {
    "type": "object",
    "properties": {
        "intent": {"type": "string", "enum": LABELS},
        "confidence": {"type": "number"},
    },
    "required": ["intent", "confidence"],
}

def generate_intent(text):
    prompt = (
        "Which intent best describes this banking customer message?\n\n"
        f"Intents:\n{LABEL_LIST}\n\n"
        f"Message: {text}\n\n"
        "Return the intent and your confidence from 0 to 1."
    )
    start = time.perf_counter()
    interaction = client.interactions.create(
        model=GEN_MODEL,
        input=prompt,
        response_format={
            "type": "text",
            "mime_type": "application/json",
            "schema": GEN_SCHEMA,
        },
        generation_config={"temperature": 0.0, "thinking_level": "minimal"},
        store=False,
    )
    latency = time.perf_counter() - start
    parsed = json.loads(interaction.output_text)
    return {
        "pred": parsed["intent"],
        "confidence": float(parsed["confidence"]),
        "latency_s": latency,
        "input_tokens": interaction.usage.total_input_tokens,
        "output_tokens": interaction.usage.total_output_tokens,
        "thought_tokens": interaction.usage.total_thought_tokens,
    }

Функция generate_intent() формирует промпт с 12 намерениями и их описаниями. Она вызывает Flash-Lite с response_format, равным нашей JSON-схеме, поэтому вывод должен быть валидным JSON с одной из 12 меток. Температура установлена в 0, а уровень размышлений — minimal, чтобы ответ был стабильным и коротким. Затем мы парсим interaction.output_text через json.loads() и читаем счётчики токенов из interaction.usage.

Мы проверили то же сообщение, что и на предыдущем шаге, во Flash-Lite — он сделал ту же ошибку с большей уверенностью:

Число thinking tokens равно 0, что подтверждает: уровень minimal ограничил Flash-Lite только записью ответа. Flash-Lite использовал меньше входных токенов, чем Decision 1 (277 против 337), потому что Decisions API считает описания опций внутри вопроса как входные токены.

Шаг 4. Классификация по одному сообщению на запрос

Теперь отправим все 180 сообщений в обе модели, по одному на запрос, после двух прогревочных вызовов каждой:

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

Этот цикл отправляет каждое сообщение в обе функции и сохраняет предсказание, уверенность, задержку и счётчики токенов строкой. Затем мы превращаем строки в DataFrame и добавляем столбец correct, который помечает, совпадает ли предсказание с истинной меткой.

Вот результаты:

Метрика

Gemini Decision 1

Gemini 3.5 Flash-Lite

Точность

84,4%

83,9%

Медианная задержка

325 мс

1 068 мс

p90 задержка

412 мс

6 483 мс

Самый медленный запрос

1,0 с

101,6 с

Запросов дольше 5 с

0 из 180

33 из 180

Среднее число входных токенов

339

279

Среднее число выходных токенов

0

25

Вот три наблюдения из этих метрик:

  • Точность: модели оказались примерно одинаковыми по точности.
  • Задержка: Decision 1 была примерно в 3 раза быстрее по медиане и заметно стабильнее, тогда как у Flash-Lite наблюдался длинный «хвост» медленных запросов.
  • Токены: Decision 1 использовала больше входных токенов из-за описаний опций, но не генерировала выходные токены.

Примечание: В измерения входит сетевой RTT из Colab, так что рассматривайте этот зазор как зависящий от среды.

Шаг 5. Проверяем калибровку

Точность показывает, как часто модель права, а калибровка — означают ли что-то её оценки уверенности. Модель хорошо откалибрована, когда её уверенность соответствует точности: если она ставит 0.8 на группе ответов, около 80% из них должны быть верными.

Чтобы это измерить, мы группируем предсказания в 10 корзин по уверенности и сравниваем среднюю уверенность каждой корзины с её точностью. Ожидаемая ошибка калибровки (ECE) — это средний разрыв, взвешенный по числу предсказаний в каждой корзине. Меньше — лучше.

def ece(conf, correct, n_bins=10):
    conf = np.asarray(conf, dtype=float)
    correct = np.asarray(correct, dtype=float)
    edges = np.linspace(0, 1, n_bins + 1)
    ids = np.clip(np.digitize(conf, edges[1:-1]), 0, n_bins - 1)
    total = 0.0
    for b in range(n_bins):
        mask = ids == b
        if mask.sum():
            total += mask.mean() * abs(conf[mask].mean() - correct[mask].mean())
    return total

Функция ece() раскладывает каждое предсказание по одной из 10 корзин по уверенности (0–0,1; 0,1–0,2 и т.д.). Для каждой корзины она берёт разницу между средней уверенностью и точностью, взвешивает по доле предсказаний в корзине и суммирует.

Вот как сравниваются обе модели:

Метрика

Gemini Decision 1

Gemini 3.5 Flash-Lite

Точность

84,4%

83,9%

Средняя уверенность

0,867

0,957

ECE

0,050

0,124

Средняя уверенность при верном ответе

0,901

0,966

Средняя уверенность при ошибке

0,686

0,912

Рисунок: Диаграммы надёжности для обеих моделей

Уверенность Decision 1 близка к её точности, ECE = 0,050. Она также заметно ниже, когда модель ошибается (0,686), чем когда права (0,901).

Flash-Lite переоценивает себя. Он сообщает в среднем 0,957, будучи правым в 83,9% случаев. Он использовал всего 9 разных значений уверенности по 180 ответам, и 158 из них были 0,95 и выше. Даже его неверные ответы в среднем имели 0,912. Число выглядит как вероятность, но это собственная оценка модели, записанная текстом.

Калибровка важна, когда вы действуете по этому показателю. Частый шаблон — принимать ответы выше порога уверенности, а остальные отправлять в запасную модель или человеку:

Порог

Decision 1: доля оставленных

Decision 1: точность на оставленных

Flash-Lite: доля оставленных

Flash-Lite: точность на оставленных

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%

В Decision 1 более высокий порог работает ожидаемо. При 0,9 она оставляет 63% сообщений с точностью 95,6%. Во Flash-Lite порог почти не помогает, потому что большинство неверных ответов тоже имеют высокую уверенность. Официальная документация рекомендует выбирать порог по размеченным примерам вашего трафика.

Шаг 6. Классифицируем 100 сообщений одним запросом

Decisions API может ответить до 1000 вопросов о одном общем вводе в одном запросе. Чтобы проверить это, мы помещаем N клиентских сообщений в один ввод и задаём по одному вопросу на сообщение.

Для Decision 1 это означает N вопросов choice с ключами от m1 до mN:

def build_batch(n):
    msgs = pool.iloc[:n]
    shared = "Banking customer messages:\n" + "".join(
        f"Message {i + 1}: {t}\n" for i, t in enumerate(msgs["text"])
    )
    return shared, list(msgs["category"])

def decide_batch(n):
    shared, gold = build_batch(n)
    questions = {
        f"m{i + 1}": {
            "type": "choice",
            "instructions": f"Which intent best describes Message {i + 1}?",
            "criteria": INTENTS,
        }
        for i in range(n)
    }
    result = client.decisions.create(
        model=DECISION_MODEL, input=shared, questions=questions
    )
    preds = [result.answers[f"m{i + 1}"].choice for i in range(n)]
    return preds, gold, result.usage

Функция build_batch() нумерует первые N сообщений и объединяет их в один общий ввод. Затем decide_batch() создаёт по одному вопросу choice на сообщение, с ключами от m1 до mN, отправляет их в одном запросе и читает по одному ответу на ключ.

Для Flash-Lite мы отправляем тот же общий ввод с JSON-схемой, в которой N полей, каждое ограничено 12 метками. Для каждого N используются одинаковые сообщения в обеих моделях, и каждая настройка запускается трижды.

Вопросов на запрос

Decision 1: медианная задержка

Flash-Lite: медианная задержка

Decision 1: входные токены

Flash-Lite: вход / выход токены

1

318 мс

888 мс

344

291 / 14

5

353 мс

858 мс

1 554

369 / 64

10

398 мс

1 063 мс

3 056

456 / 129

25

546 мс

2 753 мс

7 570

710 / 350

50

592 мс

Failed

15 100

Failed

100

59 095 мс

Failed

30 309

Failed

До 25 вопросов медианная задержка Decision 1 оставалась ниже 550 мс. Медиана Flash-Lite росла с N — от менее 1 с при 1–5 вопросах до 2,75 с при 25 — потому что ему нужно записывать каждый ответ как выходные токены. Даже при 50 вопросах медиана Decision 1 была 592 мс, хотя один из трёх прогонов занял 70 с.

Два ключевых момента для размышления:

  • Flash-Lite не справился при 50 и 100 вопросах: строки «Failed» в таблице выше — это один и тот же 400-ошибочный ответ. Он говорит, что схема «имеет слишком много состояний для обслуживания». Схема с 50+ полями, каждое из которых ограничено 12 метками, превышает лимит API.
  • Decision 1 замедлилась на 100 вопросах: каждый вопрос повторяет все 12 описаний опций, около 300 токенов на вопрос, поэтому запрос достиг 30 309 токенов, тогда как заявленная «плоская» задержка у Google покрывает контексты до 16K токенов.

Шаг 7. Урезаем запросы

Возникает очевидный вопрос: можно ли исправить замедление и отказы? Для Decision 1 используем пустые описания опций (""). Для Flash-Lite просим один список из N меток вместо N отдельных полей:

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

Вот как показала себя Decision 1 при пустых описаниях:

Вопросов на запрос

Медианная задержка

Точность

Входные токены

25

357 мс

84,0%

3 995

50

649 мс

78,0%

7 950

100

1 603 мс

83,0%

16 009

Исключение описаний примерно вдвое сократило число входных токенов. На 100 вопросах запрос уменьшился до ~16K токенов, а медиана задержки — с 59 с до 1,6 с. Точность немного упала на 25 и 50 вопросах, поэтому короткие описания — лучший компромисс, чем их отсутствие, особенно для похожих намерений.

Схема-список не помогла модели Flash-Lite. Она сработала при 25 вопросах, но по-прежнему падала при 50 и 100.

Шаг 8. Сравниваем стоимость

Наконец, рассчитаем стоимость по счётчикам токенов, которые возвращает каждый API, используя цены платного тарифа:

Модель

Цена за 1M входных токенов

Цена за 1M выходных токенов

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (включая thinking tokens)

def cost_per_request(model, input_tokens, output_tokens, thought_tokens):
    if model == "decision":
        return input_tokens * 0.10 / 1e6
    return (input_tokens * 0.30 + (output_tokens + thought_tokens) * 2.50) / 1e6

Функция cost_per_request() умножает каждый счётчик токенов на его цену за 1M токенов. Для Decision 1 учитываются только входные токены. Для Flash-Lite thinking tokens тарифицируются по цене выходных, поэтому мы прибавляем их к выходным токенам.

Вот стоимость на 1 000 запросов для каждой конфигурации:

Конфигурация

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1 сообщение на запрос

$0,034

$0,147

4,3×

5 вопросов на запрос

$0,155

$0,271

1,7×

10 вопросов на запрос

$0,306

$0,459

1,5×

25 вопросов на запрос

$0,757

$1,088

1,4×

25 вопросов, урезанные конфигурации (Шаг 7)

$0,400

$0,831

2,1×

50 вопросов на запрос

$1,510

Failed

n/a

100 вопросов, пустые описания

$1,601

Failed

n/a

На одиночных сообщениях Decision 1 была дешевле в 4,3 раза, но разрыв сокращается по мере объединения большего числа вопросов в один запрос. Общий ввод тарифицируется один раз в обоих API. Но каждый вопрос Decision 1 несёт собственную инструкцию и все 12 описаний опций, в то время как Flash-Lite видит список меток один раз и платит за короткий вывод на ответ. При 25 вопросах Decision 1 использовала 7 570 входных токенов против 710 входных и 350 выходных у Flash-Lite.

Примечание: Decisions API не поддерживает кэширование контекста и Batch API. Если вы отправляете один и тот же ввод в нескольких запросах, он тарифицируется полностью каждый раз. Поэтому когда у вас много вопросов к одному вводу, задавайте их в одном запросе, а не распределяйте по нескольким.

Когда использовать каждый подход

По результатам выше, модель решений лучше подходит, когда:

  • Ответ выбирается из фиксированного набора опций, как намерения, маршруты, инструменты или метки политики
  • Решение находится на пути запроса, где каждый пользователь ждёт его
  • Вы хотите действовать по уверенности, например отправлять неясные случаи в запасную модель или человеку
  • Нужно задать много независимых вопросов к одному вводу в одном запросе

Генеративная модель всё ещё лучше подходит, когда:

  • Нужно объяснение, извлечённое значение или произвольный текст
  • Набор возможных ответов открыт или меняется от запроса к запросу
  • Вы уже сделали генеративный вызов на этом вводе и можете добавить к нему классификацию

Используйте Decisions API, когда вам нужно

Используйте Interactions API, когда вам нужно

Вероятность «да/нет», одну опцию из фиксированного набора или оценку по фиксированной шкале

Сгенерированный текст, саммари или объяснения

Откалиброванные вероятности, по которым можно ставить порог

Извлечённые значения или объекты по вашей JSON-схеме

Много независимых проверок по одному вводу за один вызов

Вызовы инструментов с аргументами

Низкая задержка и нулевая стоимость выходных токенов

Многошаговые рассуждения

Итоги

В этом руководстве мы построили классификатор банковских намерений с Gemini Decision 1 и Gemini 3.5 Flash-Lite, а затем сравнили модели по точности, задержке, калибровке и стоимости. Четыре ключевых вывода:

  • Точность — ничья: 84,4% у Decision 1 и 83,9% у Flash-Lite; совпали вердикты по 163 из 180 сообщений.
  • Decision 1 быстрее и предсказуемее: медиана 325 мс против 1 068 мс, самый медленный запрос — 1,0 с против 101,6 с.
  • Уверенность Decision 1 пригодна к использованию: ECE = 0,050 против 0,124; повышение порога до 0,9 подняло точность на оставленных ответах с 84,4% до 95,6%. У Flash-Lite самооценка почти не отделяла верные ответы от неверных.
  • Стоимость и масштабирование зависят от формулировки вопросов: Decision 1 была в 4,3 раза дешевле на одиночных сообщениях, но каждый вопрос оплачивает свои описания опций. Держите общий ввод около 16K токенов и делайте описания опций короткими.

Эти результаты получены на одной задаче, одном датасете и в небольшом числе прогонов из ноутбука Colab. Рассматривайте их как наблюдения из демо, а не как общие заявления о производительности. 

FAQs

В чём разница между Decisions API и генеративным API?

Генеративный API записывает ответ токен за токеном и тарифицирует каждый выходной токен. Decisions API оценивает фиксированный набор опций за один прямой проход и возвращает вероятность для каждой. Он не генерирует выходные токены, поэтому вы платите только за ввод.

Точнее ли Gemini Decision 1, чем Gemini 3.5 Flash-Lite?

Не в нашем тесте. На 180 банковских сообщениях точность составила 84,4% у Decision 1 и 83,9% у Flash-Lite. Различия, которые мы измерили, были в задержке, калибровке и стоимости.

Почему Decision 1 использует больше входных токенов, чем Flash-Lite?

Инструкция каждого вопроса и описания опций считаются входом. При 12 описанных опциях это добавляло около 300 токенов на вопрос в нашем тесте. Короткие или пустые описания уменьшают это число.

Остаётся ли задержка постоянной при добавлении вопросов?

В наших прогонах медиана оставалась ниже 650 мс до 50 вопросов. На 100 вопросах с полными описаниями опций запрос достиг около 30K токенов и занял от 48 до 59 с. С пустыми описаниями те же 100 вопросов уместились примерно в 16K токенов и заняли 1,6 с.

Какие типы вопросов поддерживает Decisions API?

Decisions API поддерживает три типа вопросов, включая noul для проверок да/нет, choice для выбора одной опции из 2 до 255, и score для оценки по упорядоченной рубрике. Все три можно смешивать в одном запросе.

Темы