メインコンテンツにスキップ

Gemini Decisions API:レイテンシとコストで検証するGoogleの新しい意思決定モデル

Gemini Decision 1がテキスト生成なしで固定選択肢をスコアリングする仕組みを理解し、Decisions APIで銀行インテント分類器を構築。精度・レイテンシ・校正・コストをGemini 3.5 Flash-Liteと比較します。
· 15 分 読む

AIで探求

ほとんどのLLMアプリには小さな意思決定が数多くあります。どのツールをエージェントが呼び出すべきか?どのモデルがこの問い合わせを処理すべきか?このメッセージはポリシーに違反しているか?

現在、多くのチームは生成モデルにテキストで回答を書かせ、そのテキストをパースして意思決定を行っています。

GoogleのGemini Decisions APIは、別のアプローチを取ります。 Gemini Decision 1モデルを使い、単一のフォワードパスで固定の選択肢セットをスコアリングし、各選択肢の確率を返します。出力トークンは0課金です。

このチュートリアルでは、同じインテント分類タスクを次の2つの構成で実行します。

  • Gemini Decision 1(Decisions API経由)
  • Gemini 3.5 Flash-Lite(Interactions API経由、構造化JSON出力を使用)

精度、レイテンシ、トークン使用量、コスト、校正度を比較し、最後に1問から100問までを1リクエストにまとめて投げてみます。

このチュートリアルを終える頃には、次のことができるようになります。

  • Decisions APIにchoice質問で問い合わせ、確率と信頼度スコアを読み取る

  • Interactions APIとJSONスキーマで生成モデルのベースラインを構築する

  • 両アプローチのレイテンシ、トークン使用量、コストを測定する

  • 信頼性ダイアグラムと期待校正誤差(ECE)で、モデルの信頼度が信頼できるか検証する

  • 生成モデルより意思決定モデルがアプリに適する場面を判断する

完全なコードはこのGoogle Colabで実行できます。

意思決定モデル vs. 生成モデル

仕組みを見る前に、まず用語を定義しておきます。

  • 生成モデル: 新しいコンテンツを生成するモデルです。プロンプトを与えると、1トークンずつ応答を書きます。その応答は回答、要約、コード、ラベルなど何でもあり得ます。チャットアプリで一般的に使う多くのLLMと同様、Gemini 3.5 Flash-Liteは生成モデルです。
  • 意思決定モデル: あらかじめ定義した選択肢から選ぶモデルです。入力と固定の候補リストを与えると、テキストを一切書かずに各選択肢の確率を返します。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が閾値を超えればカード担当チームにルーティングし、超えなければ人間に回す、といった動作をコードで直接行えます。要するに:

 

生成モデル

意思決定モデル

返り値

モデルが書いたテキスト

定義した各選択肢の確率

可能な回答

オープンエンド

固定集合

得意分野

回答、要約、説明、抽出

ルーティング、ツール選択、ポリシーチェック、採点

実際には、多くのアプリが両方の役割に生成モデルを使っています。次のセクションでは、分類に関して、意思決定モデルが生成モデルより優れているかどうかをテストします。

分類器として生成モデルを使うと、回答は1トークンずつ書き出されます。今回のような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
...

これにより、測定できる3つの点が変わります。

  • レイテンシ:デコードループがないため、回答の長さに応じてレイテンシが増加しないはずです。
  • コスト:出力トークンの課金がありません。質問テキストと選択肢の説明を含む入力トークンのみを支払います。
  • 信頼度:信頼度は確率自体から得られるため、モデルが正解する頻度を反映するはずです。

トレードオフは、クローズドセットの質問にしか使えないことです。意思決定モデルは、回答の説明や値の抽出、自由記述の生成はできません。

デモ:銀行インテント分類器の構築

このデモでは、銀行インテント分類器を作成します。ラベル付き顧客メッセージ77種の公開データセットBanking77のテスト分割を使い、相互に紛れやすい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

似たインテントが多いほどタスクは難しくなり、信頼度スコアの分析がより興味深くなります。

両モデルで次の2通りに分類器を走らせます。

  • 1リクエスト=1メッセージ: 各インテント15件、計180件を、各モデルへ1件ずつ送信。
  • 1リクエスト=多数の質問: N件のメッセージを1つの共有入力に入れ、各メッセージに1問ずつ(N = 1, 5, 10, 25, 50, 100)。

両モデルで共通に保つ設定は次のとおりs:

設定

使用値

理由 

意思決定モデル

gemini-decision-1

検証対象のモデル

生成モデル

gemini-3.5-flash-lite

ローンチ記事の比較で使用された、コスト効率の良い生成ベースライン

Flash-Liteの温度

0.0

ベースラインからサンプリングノイズを除去

Flash-Liteの思考レベル

minimal

比較の焦点を推論ではなくデコードに保つ

出力形式

12ラベルのenumを持つJSONスキーマ

Flash-Liteは有効なラベルのみを返せる

選択肢の説明

各インテントにつき短文1つ

両モデルが同じラベル定義を見る

ウォームアップ呼び出し

各モデル2回

接続セットアップを測定から除外

リピート(1リクエストに多数の質問)

各設定3回

単回ではなくメディアンを報告

注:これは本デモのための実務的な設定であり、どちらのモデルに対してもチューニングした設定ではありません。

ステップ1:前提条件とセットアップ

進めるには、次が必要です。

  • Gemini APIキー(入手先: Google AI Studio)

  • Colabノートブック(または任意のPython 3環境)

  • google-genai バージョン3.2以降

Decisions APIは、プロトタイピング用にGoogle AI Studioで無償枠があるため、支払い前に試せます。私はColabで本デモを実行しましたが、任意のPython 3環境を使って構いません。

まずはパッケージをインストールします:

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

ここでgoogle-genaiはGemini API向けのGoogle製Python SDKです。client.decisions.createとclient.interactions.createメソッドがあり、それぞれDecisions APIとInteractions APIにリクエストを送ります。pandasでデータセットの読み込みと結果整理を行い、matplotlibで図を描画します。

次にクライアントを作成します。Decisions APIはv1betaの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"

ここでgenai.Client()はColabのシークレットや環境変数に設定したGEMINI_API_KEYからAPIキーを読み込み、http_optionsでDecisions APIがあるv1beta APIを指定しています。

続いてBanking77データセットを読み込み、12インテントを定義します。各インテントには両モデルが参照する1文の説明を付けます:

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というキーで1問を聞きます:

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()は、1件のメッセージをinputに、12インテントを選択肢に持つchoice質問を1つ送ります。time.perf_counter()で呼び出し時間を計測し、トップの選択、信頼度、全選択肢の確率、トークン数をレスポンスから読み取ります。

各回答は次の3フィールドを持ちます:

  • choice: 最も確率が高い選択肢

  • probabilities: 各選択肢の確率(合計1)

  • confidence: トップ回答が正しい推定確率

usageオブジェクトは入力トークンを報告し、total_output_tokensは常に0です。

サンプルの最初のメッセージの結果は次のとおりです:

モデルは似たインテントを取り違えましたが、信頼度0.846は不確実性があることを示しています。良い点は、正しいインテントcard_arrivalが2位で、残りの確率のほとんど(約0.15)を占めていたことです。他はほぼゼロでした。

ステップ3:Flash-Liteで分類

生成ベースラインとして、同じ12ラベルのenumを持つ構造化出力を用い、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インテントとその説明を含むプロンプトを構築します。response_formatにJSONスキーマを指定してFlash-Liteを呼び出し、出力が12ラベルのいずれかを含む有効なJSONになるようにします。温度は0、思考レベルはminimalに設定し、回答を安定かつ短く保ちます。interaction.output_textをjson.loads()でパースし、interaction.usageからトークン数を読み取ります。

前ステップと同じメッセージをFlash-Liteでテストしたところ、同じ誤りをより高い信頼度で犯しました:

思考トークンは0で、minimalが回答の記述のみに抑えたことを確認できます。Decisions APIは質問内の選択肢説明も入力としてカウントするため、Flash-Liteの入力トークンはDecision 1より少なくなりました(277対337)。

ステップ4:1リクエスト=1メッセージで分類

では、ウォームアップ2回の後、180件すべてを両モデルに1件ずつ送ってみます:

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

各メッセージを両関数に送って、予測、信頼度、レイテンシ、トークン数を1行として保存します。行をDataFrameにし、予測が真のラベルと一致したかどうかを示すcorrect列を追加します。

結果は次のとおりs:

指標

Gemini Decision 1

Gemini 3.5 Flash-Lite

精度

84.4%

83.9%

レイテンシ(中央値)

325 ms

1,068 ms

p90レイテンシ

412 ms

6,483 ms

最も遅いリクエスト

1.0 s

101.6 s

5秒超のリクエスト

0 / 180

33 / 180

平均入力トークン

339

279

平均出力トークン

0

25

このメトリクスからわかったことは次の3点です。

  • 精度: 両モデルともほぼ同等の精度でした。
  • レイテンシ: Decision 1は中央値で約3倍速く、はるかに一貫していました。一方、Flash-Liteは遅いリクエストのロングテールがありました。
  • トークン: Decision 1は選択肢説明が入力に数えられるため入力トークンが多い一方、出力トークンは生成ゼロでした。

注:計測には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%でした。180回答中、使用した信頼度は9種類しかなく、そのうち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:1リクエストで100メッセージを分類

Decisions APIは、1つの共有入力に対し最大1,000問までを1リクエストで回答できます。これを試すため、N件の顧客メッセージを1つの入力に入れ、各メッセージに1問ずつ尋ねます。

Decision 1では、m1からmNのキーでN個のchoice質問を作ります:

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件のメッセージに番号を振って1つの共有入力に結合します。decide_batch()は各メッセージに対しm1〜mNのchoice質問を作成し、1リクエストでまとめて送信、各キーに対応する回答を読み取ります。

Flash-Liteでは、同じ共有入力に対し、12ラベルに制限されたNフィールドを持つJSONスキーマを送ります。各Nは両モデルで同じメッセージを用い、各設定を3回ずつ実行します。

1リクエスト当たりの質問数

Decision 1:レイテンシ中央値

Flash-Lite:レイテンシ中央値

Decision 1:入力トークン

Flash-Lite:入力/出力トークン

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

失敗

15,100

失敗

100

59,095 ms

失敗

30,309

失敗

25問までは、Decision 1のレイテンシ中央値は550ms未満に留まりました。Flash-Liteの中央値はNに応じて増加し、1〜5問で1秒未満から、25問で2.75秒に達しました。各回答を出力トークンとして書く必要があるためです。50問でもDecision 1の中央値は592msでしたが、3回のうち1回は70秒かかりました。

検討すべき重要ポイントは2つあります。

  • Flash-Liteは50問と100問で失敗: 上表の「失敗」は同じ400エラーで、スキーマが「提供に対して状態が多すぎる」ことを示しています。50以上のフィールドを持ち、各フィールドが12ラベルに制限されるスキーマはAPIの許容範囲を超えます。
  • Decision 1は100問で遅くなった: 各質問が12の選択肢説明(約300トークン/問)を繰り返すため、リクエストは30,309トークンに達しました。Googleのレイテンシ一定の主張はコンテキスト16Kトークンまでを対象としています。

ステップ7:リクエストの削減

ここで当然の疑問:遅延や失敗は解消できるのか?Decision 1では選択肢説明を空文字("")にします。Flash-Liteでは、N個の別フィールドではなくN要素のラベルリストを1つ要求します:

# 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の結果は次のとおりです:

1リクエスト当たりの質問数

レイテンシ中央値

精度

入力トークン

25

357 ms

84.0%

3,995

50

649 ms

78.0%

7,950

100

1,603 ms

83.0%

16,009

説明を削除すると、入力トークンは概ね半減しました。100問では約16Kトークンまで下がり、レイテンシ中央値は59秒から1.6秒に低下しました。25問と50問で精度がやや低下したため、特に似たインテントでは、説明なしより短い説明のほうがバランスが良いです。

ラベルリストのスキーマはFlash-Liteには効果がありませんでした。25問では動作しましたが、50問と100問では依然として失敗しました。

ステップ8:コスト比較

最後に、各APIが返すトークン数から、有料ティアの価格でコストを算出します。

モデル

入力価格(100万トークンあたり)

出力価格(100万トークンあたり)

Gemini Decision 1

$0.10

$0

Gemini 3.5 Flash-Lite

$0.30

$2.50(思考トークン含む)

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()は、各トークン数に100万トークンあたりの価格を掛けます。Decision 1では入力トークンのみが対象です。Flash-Liteでは思考トークンは出力価格で課金されるため、出力トークンに加算します。

各構成での1,000リクエストあたりのコストは次のとおりです:

構成

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1メッセージ/リクエスト

$0.034

$0.147

4.3x

5質問/リクエスト

$0.155

$0.271

1.7x

10質問/リクエスト

$0.306

$0.459

1.5x

25質問/リクエスト

$0.757

$1.088

1.4x

25質問、削減構成(ステップ7)

$0.400

$0.831

2.1x

50質問/リクエスト

$1.510

失敗

n/a

100質問、空の説明

$1.601

失敗

n/a

単一メッセージではDecision 1が4.3倍安価でしたが、1リクエストに質問を多く束ねるほど差は縮まります。共有入力は両APIで1回分の課金です。ただし、Decision 1では各質問が指示文と12の選択肢説明を持つ一方、Flash-Liteはラベルリストを1度だけ見て、各回答で短い出力を支払います。25問では、Decision 1は7,570入力トークン、Flash-Liteは710入力+350出力トークンでした。

注:Decisions APIはコンテキストキャッシュやBatch APIをサポートしていません。同じ入力を複数回送ると、その都度全量が課金されます。同一入力に多数の質問がある場合は、複数回に分けず、1リクエストでまとめて聞いてください。

それぞれを使うべき場面

上記の実行結果に基づくと、意思決定モデルが適するのは次のような場合です。

  • 回答がインテント、ルート、ツール、ポリシーラベルのように固定の集合から選ばれる
  • 意思決定がリクエストパス上にあり、全ユーザーがそれを待つ
  • 信頼度に基づき、曖昧なケースをフォールバックや人間に回したい
  • 同一入力に対して独立な質問を多数、1リクエストで行いたい

一方、生成モデルが依然として適するのは次のような場合です。

  • 説明、抽出値、自由記述のいずれかが必要
  • 可能な回答集合がオープンである、またはリクエストごとに変わる
  • その入力に対してすでに生成呼び出しを行っており、分類を追加で載せられる

Decisions APIを使うべきとき

Interactions APIを使うべきとき

はい/いいえの確率、固定集合から1つの選択、固定尺度での評価が必要

生成テキスト、要約、説明が必要

閾値設定に使える校正済みの確率が必要

独自のJSONスキーマに従う抽出値やオブジェクトが必要

同一入力に対して多数の独立チェックを1回で行いたい

引数付きのツール呼び出しが必要

低レイテンシかつ出力トークンコストゼロが必要

マルチステップ推論が必要

まとめ

このチュートリアルでは、Gemini Decision 1とGemini 3.5 Flash-Liteで銀行インテント分類器を構築し、精度・レイテンシ・校正・コストを算出して両モデルを比較しました。主なポイントは次の4つです。

  • 精度は引き分け: Decision 1が84.4%、Flash-Liteが83.9%で、180件中163件が同じ判定でした。
  • Decision 1は速く予測可能: レイテンシ中央値は325ms対1,068ms、最遅リクエストは1.0秒対101.6秒でした。
  • Decision 1の信頼度は活用可能: ECEは0.050(対0.124)で、閾値を0.9に上げると保持回答の精度は84.4%から95.6%に向上。Flash-Liteの自己申告の信頼度は正誤の分離が不十分でした。
  • コストとスケーリングは質問の書き方に依存: 単一メッセージではDecision 1が4.3倍安価でしたが、各質問で選択肢説明の課金が発生します。合計入力は約16Kトークン以下に抑え、選択肢の説明は短く保ちましょう。

これらの結果は、1つのタスク、1つのデータセット、Colabノートブックからの少数回の実行に基づくものです。汎用的な性能主張ではなく、デモからの観察として扱ってください。

FAQs

Decisions APIと生成APIの違いは何ですか?

生成APIは回答をトークンごとに書き出し、各出力トークンが課金されます。Decisions APIは固定の選択肢集合を1回のフォワードパスでスコアリングし、各選択肢の確率を返します。出力トークンは生成しないため、支払うのは入力分のみです。

Gemini Decision 1はGemini 3.5 Flash-Liteより高精度ですか?

本テストではそうではありません。銀行メッセージ180件に対し、精度はDecision 1が84.4%、Flash-Liteが83.9%でした。差が出たのはレイテンシ、校正、コストです。

Decision 1はなぜFlash-Liteより入力トークンが多いのですか?

各質問の指示文と選択肢の説明が入力としてカウントされます。本テストでは、説明付き12選択肢で1質問あたり約300トークン増えました。短い説明や空の説明にすると削減できます。

質問を増やしてもレイテンシは一定のままですか?

今回の実行では、50問までは中央値が650ms未満に留まりました。100問・フル説明では約3万トークンに達し、48〜59秒かかりました。空の説明にすると同じ100問が約16Kトークンに収まり、1.6秒でした。

Decisions APIはどの質問タイプをサポートしていますか?

Decisions APIは3種の質問タイプをサポートします。noulははい/いいえ判定、choiceは2〜255から1つ選択、scoreは順序付きルーブリックでの採点です。1リクエストで3種を混在可能です。

トピック