Ana içeriğe geç

Gemini Decisions API: Google’un Yeni Karar Modelini Gecikme ve Maliyet Açısından Test Etme

Gemini Decision 1’in metin üretmeden sabit seçenekleri nasıl puanladığını öğrenin, Decisions API ile bir bankacılık niyet sınıflandırıcı oluşturun ve doğruluk, gecikme, kalibrasyon ve maliyet açısından Gemini 3.5 Flash-Lite ile karşılaştırın.
· 15 dk. oku

Yapay Zeka ile Keşfedin

Çoğu LLM uygulaması küçük kararlarla doludur: Aracının hangi aracı çağırması gerekir? Bu sorguyu hangi model ele almalı? Bu mesaj bir politikayı ihlal ediyor mu?

Bugün birçok ekip bu soruları, üretken bir modele metin olarak yanıt yazdırıp sonra o metni ayrıştırarak karar verdirerek yanıtlıyor.

Google'ın Gemini Decisions API farklı bir yaklaşım benimsiyor. Gemini Decision 1 modelini kullanarak sabit bir seçenek kümesini tek bir ileri geçişte puanlıyor ve her seçenek için bir olasılık döndürüyor; çıktı jetonu ücreti ise sıfır.

Bu eğitimde, aynı niyet sınıflandırma görevini iki kurulumda çalıştıracağız:

  • Gemini Decision 1 Decisions API üzerinden
  • Gemini 3.5 Flash-Lite Interactions API üzerinden, yapısal JSON çıktısıyla

Bunları doğruluk, gecikme, token kullanımı, maliyet ve kalibrasyon açısından karşılaştıracağız; ardından her ikisini de tek bir istekte 1’den 100 soruya yükselteceğiz.

Bu eğitimin sonunda şunları öğrenmiş olacaksınız:

  • Decisions API’yi choice sorularıyla çağırmak ve olasılıklarını ile güven puanlarını okumak

  • Interactions API ve bir JSON şeması ile üretken bir kıyas çizgisi oluşturmak

  • Her iki yaklaşım için gecikme, token kullanımı ve maliyeti ölçmek

  • Bir modelin güveninin güvenilir olup olmadığını, güvenilirlik diyagramı ve beklenen kalibrasyon hatası (ECE) ile kontrol etmek

  • Uygulamanızda üretken bir modele kıyasla bir karar modelinin ne zaman daha uygun olduğuna karar vermek

Tüm kodu bu Google Colab’da çalıştırabilirsiniz.

Karar Modelleri ve Üretken Modeller

Her birinin nasıl çalıştığına bakmadan önce, iki terimi tanımlayalım.

  • Üretken model: Bu model yeni içerik üretir. Ona bir istem verirsiniz ve yanıtı birer token halinde yazar. Bu yanıt bir cevap, özet, kod veya etiket gibi herhangi bir şey olabilir. Sohbet uygulamalarında kullandığımız çoğu LLM gibi Gemini 3.5 Flash-Lite bir üretken modeldir.
  • Karar modeli: Bir karar modeli, sizin tanımladığınız seçenekler arasından seçim yapar. Ona bir girdi ve sabit bir olası yanıt listesi verirsiniz; o da tek bir satır metin bile yazmadan her seçenek için olasılığı bildirir. Gemini Decision 1 bir karar modelidir.

İşte bir örnek. 

Bir müşteri bankaya yazıyor: "Kartım hâlâ gelmedi. Ne zaman ulaşır?"

Eğer bir üretken modele "Bu müşteri ne istiyor?" diye sorarsanız, şöyle yanıt verebilir:

“Müşteri yeni bir kart bekliyor ve ne zaman geleceğini öğrenmek istiyor.”

Bu, bir insanın okuması için iyi bir yanıttır. Ancak uygulamanız mesajı doğru ekibe yönlendirmeye ihtiyaç duyuyorsa, artık kodunuzun bu cümleyi bir etikete dönüştürmesi gerekir. Bir JSON şemasıyla etiketi zorunlu kılabilirsiniz, ancak model yine de bunu token token yazar.

Buna karşılık, aynı şeyi bir karar modeline sorarsanız önce seçenekleri verirsiniz; örneğin card_arrival, lost_or_stolen_card ve exchange_rate. O da her biri için bir olasılık döndürür:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Kodunuz daha sonra bu olasılığa doğrudan göre hareket edebilir; örneğin card_arrival eşik değerinin üzerindeyse kart ekibine yönlendirebilir, değilse bir insana gönderebilir. Kısacası:

 

Üretken model

Karar modeli

Döndürdüğü

Kendi yazdığı metin

Sizin tanımladığınız her seçenek için bir olasılık

Olası yanıtlar

Ucu açık

Sabit küme

Uygun olduğu durumlar

Yanıtlar, özetler, açıklamalar ve çıkarım

Yönlendirme, araç seçimi, politika kontrolleri ve notlama

Pratikte, birçok uygulama her iki işi de üretken bir modelle yapar. Bir sonraki bölümde test edeceğimiz şey şu: sınıflandırma kısmında bir karar modeli, üretken bir modelden daha iyi mi?

Bir üretken modeli sınıflandırıcı olarak kullandığınızda, yanıtı birer token halinde yazar. Bizimki gibi bir JSON cevabı için, çıktı oluşturulurken şöyle görünür:

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

Her token ayrı bir çözümleme adımıdır ve her çıktı tokenı ücretlendirilir. Bir güven puanı isterseniz, modelin bu sayıyı da yazması gerekir. Bu sayı, modelin iç yapısından ölçülen bir olasılık değil, modelin kendisi hakkındaki kendi tahminidir.

Buna karşılık, bir karar modeli yazma adımını atlar. Seçenekleri baştan verirsiniz ve girdiyle tüm seçenekleri tek bir ileri geçişte puanlar. Sonuç, her seçenek için bir olasılıktır:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Bu, ölçebileceğiniz üç şeyi değiştirir:

  • Gecikme: Çözümleme döngüsü yoktur, bu nedenle gecikme yanıtın uzunluğuyla artmamalıdır.
  • Maliyet: Ücretlendirilecek çıktı tokenı yoktur. Yalnızca soru metniniz ve seçenek açıklamalarınızı içeren girdi tokenları için ödeme yaparsınız.
  • Güven: Güven puanı doğrudan olasılıklardan gelir; dolayısıyla modelin ne sıklıkla doğru olduğuyla daha uyumlu olmalıdır.

Ödün ise yalnızca kapalı küme sorular sorabilmenizdir. Bir karar modeli cevabını açıklayamaz, bir değer çıkaramaz veya serbest metin yazamaz.

Demo: Bankacılık Niyet Sınıflandırıcı Oluşturma

Bu demoda bir bankacılık niyet sınıflandırıcı oluşturacağız. 77 niyetle etiketlenmiş müşteri mesajlarından oluşan herkese açık Banking77 veri setinin test bölümünü kullanacağız ve birbiriyle kolay karıştırılan 12 niyeti tutacağız:

  • card_arrival ve card_delivery_estimate

  • pending_card_payment, declined_card_payment ve card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient ve balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate ve top_up_failed

Benzer niyetler görevi zorlaştırır; bu da güven puanlarını incelemeyi daha ilginç kılar.

Sınıflandırıcıyı iki modelle iki şekilde çalıştıracağız:

  • İstek başına bir mesaj: Her niyet için 15 olmak üzere 180 mesaj; her modele teker teker gönderilir.
  • İstek başına çok sayıda soru: N mesaj tek bir ortak girdide toplanır; her mesaj için bir soru olacak şekilde; N = 1, 5, 10, 25, 50 ve 100.

Her iki model için aynı tuttuğumuz ayarlar s şunlardır:

Ayar

Kullanılan değer

Neden 

Karar modeli

gemini-decision-1

Test edilen model

Üretken model

gemini-3.5-flash-lite

Lansman yazısı karşılaştırmasında kullanılan maliyet etkin üretken kıyas çizgisi

Flash-Lite sıcaklığı

0.0

Kıyas çizgisinden örnekleme gürültüsünü kaldırır

Flash-Lite düşünme seviyesi

minimal

Karşılaştırmayı akıl yürütmeden ziyade çözümlemeye odaklar

Çıktı biçimi

12 etiketin enum’una sahip JSON şeması

Flash-Lite yalnızca geçerli bir etiket döndürebilir

Seçenek açıklamaları

Niyet başına bir kısa cümle

Her iki model de aynı etiket tanımlarını görür

Isınma çağrıları

Model başına 2

Bağlantı kurulumunu ölçümlerin dışında tutar

Tekrarlar (istek başına çok soru)

Ayar başına 3

Tek bir çalıştırma yerine ortanca raporlanır

Not: Bunlar bu demo için çalışan ayarlardır; her iki model için de ince ayar yapılmış ayarlar değildir.

Adım 1: Önkoşullar ve kurulum

Takip edebilmek için şunlara ihtiyacınız var:

  • Şuradan bir Gemini API anahtarı: Google AI Studio

  • Bir Colab defteri (veya herhangi bir Python 3 ortamı)

  • google-genai sürüm 3.2 veya sonrası

Decisions API, prototipleme için Google AI Studio’da ücretsiz bir katmana sahiptir; bu sayede ödeme yapmadan önce deneyebilirsiniz. Bu demoyu Colab üzerinde çalıştırdım; ancak dilediğiniz herhangi bir Python 3 ortamını kullanabilirsiniz. 

Paketleri kurarak başlayalım:

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

Burada google-genai, Gemini API için Google’ın Python SDK’sıdır. Bize Decisions API ve Interactions API’ye istek gönderen client.decisions.create ve client.interactions.create metodlarını sağlar. pandas veri kümesini yüklemek ve sonuçları düzenlemek, matplotlib ise şekilleri çizmek için kullanılır.

Sonraki adımda istemciyi oluşturacağız. Decisions API v1beta API sürümünü gerektirir:

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"

Burada genai.Client(), API anahtarını Colab’de gizliler altında veya bir ortam değişkeni olarak ayarlanmış GEMINI_API_KEY’ten okur; http_options ise Decisions API’nin bulunduğu v1beta API’sine işaret eder. 

Ardından Banking77 veri kümesini yükleyip 12 niyetimizi tanımlayacağız. Her niyet, her iki modelin de göreceği tek cümlelik bir açıklama alır:

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

Yukarıdaki kod parçacığı Banking77 test bölümünü bir CSV dosyası olarak indirir ve yalnızca 12 niyetimizden biriyle etiketlenmiş satırları tutar. Ardından sabit bir rastgele tohumla niyet başına 15 mesaj örnekler; böylece her çalıştırmada aynı örneği elde edersiniz. Son .sample(frac=1) satırları karıştırarak niyetleri karışık hale getirir.

Bu, niyet başına 15 olmak üzere 180 mesaj verir.

Adım 2: Decisions API ile sınıflandırma

choice sorusu, her seçenek kimliğini bir açıklamayla eşleyen bir sözlük alır. Mesajı input olarak iletir ve intent anahtarlı bir soru sorarız:

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() fonksiyonu bir mesajı input olarak ve 12 niyetimizin seçenek olduğu bir choice sorusunu gönderir. Çağrıyı time.perf_counter() ile zamanlarız; ardından yanıttan en yüksek seçenek, güven, tüm seçenek olasılıkları ve token sayılarını okuruz.

Her yanıtta üç alan bulunur:

  • choice: En yüksek olasılığa sahip seçenek

  • probabilities: Her seçenek için bir olasılık; toplamı 1’dir

  • confidence: En iyi yanıtın doğru olma olasılığına dair tahmin

usage nesnesi girdi tokenlarını raporlar ve total_output_tokens daima 0’dır.

Örneğimizdeki ilk mesaj için sonuç şöyle:

Model benzer iki niyeti karıştırdı; ancak 0.846’lık güveni bir miktar belirsizlik gösteriyor. İyi olan kısım, doğru niyet olan card_arrival’ın kalan olasılığın neredeyse tamamıyla (yaklaşık 0.15) ikinci gelmesiydi. Diğer tüm seçenekler sıfıra yakındı.

Adım 3: Flash-Lite ile sınıflandırma

Üretken kıyas çizgisi için, aynı 12 etiketin enum’unu içeren yapısal çıktı kullanıyoruz; böylece Flash-Lite yalnızca geçerli bir etiket döndürebilir. Ayrıca çoğu uygulamanın üretken bir modelden güven puanı elde ettiği şekilde, 0 ile 1 arasında bir güven istiyoruz:

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() fonksiyonu 12 niyet ve açıklamalarını içeren bir istem derler. Flash-Lite’ı response_format’ı JSON şemamıza ayarlı şekilde çağırır; bu nedenle çıktı, 12 etiketten birini içeren geçerli JSON olmalıdır. Sıcaklık 0 ve düşünme seviyesi minimal olarak ayarlanmıştır; böylece yanıt istikrarlı ve kısa kalır. Ardından interaction.output_text öğesini json.loads() ile ayrıştırır ve interaction.usage içinden token sayılarını okuruz.

Aynı mesajı önceki adımda Flash-Lite ile de test ettim ve daha yüksek güvenle aynı hatayı yaptı:

Düşünme tokenları 0’dır; bu da minimal düşünmenin Flash-Lite’ı yalnızca yanıtı yazmakla sınırladığını doğrular. Decisions API seçenek açıklamalarını soru içinde girdi olarak saydığı için Flash-Lite, Decision 1’den daha az girdi tokenı kullandı (277’ye karşı 337).

Adım 4: İstek başına bir mesajı sınıflandırma

Şimdi, her biri için iki ısınma çağrısından sonra tüm 180 mesajı her iki modele de birer istek halinde gönderelim:

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

Bu döngü her mesajı her iki fonksiyona da gönderir ve tahmin, güven, gecikme ve token sayılarını bir satır olarak kaydeder. Daha sonra satırları bir DataFrame’e dönüştürür ve her tahminin gerçek etiketle eşleşip eşleşmediğini işaretleyen bir doğru sütunu ekleriz.

İşte sonuçlar:

Metri̇k

Gemini Decision 1

Gemini 3.5 Flash-Lite

Doğruluk

%84,4

%83,9

Ortanca gecikme

325 ms

1.068 ms

p90 gecikme

412 ms

6.483 ms

En yavaş istek

1,0 s

101,6 s

5 s üzerindeki istekler

180’de 0

180’de 33

Ortalama girdi tokenı

339

279

Ortalama çıktı tokenı

0

25

Bu metriklerden öğrendiğimiz üç çey şunlar:

  • Doğruluk: Her iki model de yaklaşık olarak eşit derecede doğruydu.
  • Gecikme: Decision 1 ortancada yaklaşık 3 kat daha hızlı ve çok daha tutarlıydı; Flash-Lite ise yavaş isteklerden oluşan uzun bir kuyruğa sahipti.
  • Tokenlar: Decision 1 daha fazla girdi tokenı kullandı çünkü seçenek açıklamaları girdi sayılıyor; ancak çıktı tokenı üretmedi.

Not: Zamanlamamız Colab’dan ağ gidiş-dönüşünü içerir; bu nedenle bu farkı kurulumdan bağımsız düşünün.

Adım 5: Kalibrasyonu kontrol etme

Doğruluk, bir modelin ne sıklıkla doğru olduğunu söyler; ancak kalibrasyon, güveninin bir anlamı olup olmadığını gösterir. Bir modelin güveni doğruluğuyla eşleştiğinde iyi kalibre edilmiştir; yani bir yanıt grubunda 0,8 diyorsa, bunların yaklaşık %80’i doğru olmalıdır.

Bunu ölçmek için tahminleri 10 güven kutusuna gruplandırır ve her kutunun ortalama güvenini doğruluğuyla karşılaştırırız. Beklenen kalibrasyon hatası (ECE), her kutuya düşen tahmin sayısıyla ağırlıklandırılmış ortalama farktır. Daha düşük olan daha iyidir.

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() fonksiyonu her tahmini güvenine göre 10 kutudan birine yerleştirir (0’dan 0,1’e, 0,1’den 0,2’ye vb.). Her kutu için ortalama güven ile doğruluk arasındaki farkı alır, o kutudaki tahminlerin payıyla ağırlıklandırır ve sonuçları toplar.

İki model nasıl karşılaştırıldı:

Metri̇k

Gemini Decision 1

Gemini 3.5 Flash-Lite

Doğruluk

%84,4

%83,9

Ortalama güven

0,867

0,957

ECE

0,050

0,124

Doğruyken ort. güven

0,901

0,966

Yanlışken ort. güven

0,686

0,912

Şekil: Her iki model için güvenilirlik diyagramları

Decision 1’in güveni doğruluğuna yakındır; ECE değeri 0,050’dir. Ayrıca model yanlışken (0,686) doğruykenkinden (0,901) belirgin şekilde daha düşüktür.

Flash-Lite aşırı kendinden emindir. Ortalama 0,957 bildirirken, %83,9 oranında doğrudur. 180 yanıt arasında yalnızca 9 farklı güven değeri kullandı ve 158’i 0,95 veya üzerindeydi. Yanlış yanıtlarının ortalaması bile 0,912 idi. Rakam bir olasılık gibi görünse de modelin metin olarak yazdığı kendi tahminidir.

Eylemi puana bağladığınızda kalibrasyon önemlidir. Yaygın bir desen, bir eşik değerin üzerindeki yanıtları kabul etmek ve kalanları bir yedek modele veya insana göndermektir:

Eşik

Decision 1: tutulan pay

Decision 1: tutulanlarda doğruluk

Flash-Lite: tutulan pay

Flash-Lite: tutulanlarda doğruluk

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 ile daha yüksek bir eşik beklendiği gibi çalışır. 0,9’da mesajların %63’ünü %95,6 doğrulukla tutar. Flash-Lite’ta eşik pek yardımcı olmaz; çünkü yanlış yanıtlarının çoğunun da güveni yüksektir. Resmî dokümanlar, eşiğinizi kendi trafiğinizin etiketli örneklerinden seçmenizi önerir.

Adım 6: Tek bir istekte 100 mesajı sınıflandırma

Decisions API, tek bir istekte ortak bir girdi hakkında 1.000’e kadar soruyu yanıtlayabilir. Bunu test etmek için N müşteri mesajını tek bir girdiye koyar ve mesaj başına bir soru sorarız.

Decision 1 için bu, m1’den mN’ye anahtarlanmış N adet choice soru demektir:

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

Burada build_batch() fonksiyonu ilk N mesajı numaralandırır ve tek bir ortak girdi halinde birleştirir. Ardından decide_batch(), mesaj başına bir choice sorusu oluşturur; m1’den mN’ye anahtarlar, hepsini tek bir istekte gönderir ve her anahtar için bir yanıt okur.

Flash-Lite için, aynı ortak girdiyi N alanı olan ve her biri 12 etiketle sınırlı bir JSON şemasıyla göndeririz. Her N, her iki model için de aynı mesajları kullanır ve her ayar üç kez çalıştırılır.

İstek başına soru

Decision 1: ortanca gecikme

Flash-Lite: ortanca gecikme

Decision 1: girdi tokenları

Flash-Lite: girdi / çıktı tokenları

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

Başarısız

15.100

Başarısız

100

59.095 ms

Başarısız

30.309

Başarısız

25 soruya kadar Decision 1’in ortanca gecikmesi 550 ms’nin altında kaldı. Flash-Lite’ın ortancası N ile arttı; 1 ile 5 soruda 1 saniyenin altından, 25’te 2,75 saniyeye çıktı; çünkü her yanıtı çıktı tokenları olarak yazmak zorunda. 50 soruda bile, Decision 1’in ortancası 592 ms idi; ancak üç çalıştırmadan biri 70 s sürdü.

Düşünmeye değer iki önemli nokta:

  • Flash-Lite 50 ve 100 soruda başarısız oldu: Yukarıdaki tablodaki "Başarısız" satırlarının tümü aynı 400 hatasıdır. Şemanın "sunum için çok fazla duruma" sahip olduğunu gösterir. Her biri 12 etiketle sınırlı 50 veya daha fazla alan içeren bir şema, API’nin kabul ettiğinden fazladır.
  • Decision 1, 100 soruda yavaşladı: Her soru tüm 12 seçenek açıklamasını tekrar eder; soru başına yaklaşık 300 token; bu nedenle istek 30.309 tokena ulaştı; oysa Google’ın sabit gecikme iddiası 16K tokene kadar olan bağlamları kapsar.

Adım 7: İstekleri kırpma

Şimdi bariz bir soru ortaya çıkıyor: yavaşlamayı ve hataları düzeltebilir miyiz? Decision 1 için seçenek açıklamalarını boş ("") kullanıyoruz. Flash-Lite için N ayrı alan yerine N etiketin bir listesini istiyoruz:

# Decision 1: yalnızca seçenek kimlikleri, açıklama yok
"criteria": {k: "" for k in LABELS}

# Flash-Lite: N alan yerine tek bir liste alanı
schema = {
    "type": "object",
    "properties": {"intents": {
        "type": "array",
        "items": {"type": "string", "enum": LABELS},
        "minItems": n, "maxItems": n,
    }},
    "required": ["intents"],
}

Decision 1 boş açıklamalarla nasıl performans gösterdi:

İstek başına soru

Ortanca gecikme

Doğruluk

Girdi tokenları

25

357 ms

%84,0

3.995

50

649 ms

%78,0

7.950

100

1.603 ms

%83,0

16.009

Açıklamaları kaldırmak girdi tokenlarını yaklaşık yarıya indirdi. 100 soruda istek yaklaşık 16K tokena düştü ve ortanca gecikme 59 saniyeden 1,6 saniyeye indi. Doğruluk 25 ve 50 soruda biraz düştü; bu nedenle özellikle benzer niyetlerde, hiç olmamasındansa kısa açıklamalar daha iyi bir orta yoldur.

Liste şeması Flash-Lite modeline yardımcı olmadı. 25 soruda çalıştı; ancak 50 ve 100’de yine başarısız oldu.

Adım 8: Maliyeti karşılaştırma

Son olarak, her API’nin döndürdüğü token sayılarından, ücretli katman fiyatlarını kullanarak maliyeti hesaplıyoruz:

Model

1M girdi token başına fiyat

1M çıktı token başına fiyat

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (düşünme tokenları dahil)

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() fonksiyonu, her token sayısını 1M token başına fiyatıyla çarpar. Decision 1 için yalnızca girdi tokenları sayılır. Flash-Lite için düşünme tokenları çıktı fiyatından ücretlendirildiğinden, çıktı tokenlarına eklenir.

Her kurulum için 1.000 istek başına maliyet şöyledir:

Kurulum

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

İstek başına 1 mesaj

$0,034

$0,147

4,3x

İstek başına 5 soru

$0,155

$0,271

1,7x

İstek başına 10 soru

$0,306

$0,459

1,5x

İstek başına 25 soru

$0,757

$1,088

1,4x

25 soru, kırpılmış kurulumlar (Adım 7)

$0,400

$0,831

2,1x

İstek başına 50 soru

$1,510

Başarısız

yok

100 soru, boş açıklamalar

$1,601

Başarısız

yok

Tekil mesajlarda Decision 1, 4,3 kat daha ucuzdu; ancak tek bir isteğe daha fazla soru topladıkça fark daralır. Ortak girdi her iki API’de de bir kez ücretlendirilir. Ancak her Decision 1 sorusu kendi yönergesini ve tüm 12 seçenek açıklamasını taşırken, Flash-Lite etiket listesini yalnızca bir kez görür ve yanıt başına kısa bir çıktı için ödeme yapar. 25 soruda Decision 1, Flash-Lite’ın 710 girdi ve 350 çıktı tokenına karşı 7.570 girdi tokenı kullandı.

Not: Decisions API, bağlam önbellekleme veya Toplu API’yi desteklemez. Aynı girdiyi birkaç istekte gönderirseniz, her seferinde tamamen ücretlendirilir. Bu nedenle, aynı girdi hakkında çok sayıda sorunuz olduğunda, bunları çağrılar arasında yaymak yerine tek bir istekte sorun.

Hangi Yaklaşımı Ne Zaman Kullanmalı

Yukarıdaki çalıştırmalara dayanarak, şu durumlarda bir karar modeli daha uygundur:

  • Yanıt, niyetler, rotalar, araçlar veya politika etiketleri gibi sabit bir seçenek kümesinden geliyorsa
  • Karar, her kullanıcının beklediği istek yolunda yer alıyorsa
  • Güvene göre hareket etmek istiyorsanız; örneğin belirsiz durumları bir yedek modele veya insana göndermek
  • Aynı girdi hakkında tek bir istekte birçok bağımsız soru sormanız gerekiyorsa

Şu durumlarda ise üretken bir model hâlâ daha uygundur:

  • Bir açıklama, çıkarılmış bir değer veya herhangi bir serbest metne ihtiyacınız varsa
  • Olası yanıtların kümesi açıksa veya istek başına değişiyorsa
  • Zaten o girdi üzerinde üretken bir çağrı yaptıysanız ve sınıflandırmayı ona ekleyebiliyorsanız

Şuna ihtiyacınız olduğunda Decisions API’yi kullanın

Şuna ihtiyacınız olduğunda Interactions API’yi kullanın

Evet/hayır olasılığı, sabit bir kümeden bir seçenek veya sabit bir ölçekte derecelendirme

Üretilmiş metin, özetler veya açıklamalar

Eşiklendirebileceğiniz kalibre edilmiş olasılıklar

Kendi JSON şemanıza uyan çıkarılmış değerler veya nesneler

Tek bir çağrıda aynı girdi üzerinde çok sayıda bağımsız kontrol

Argümanlarla araç çağrıları

Düşük gecikme ve sıfır çıktı token maliyeti

Çok adımlı akıl yürütme

Son Düşünceler

Bu eğitimde Gemini Decision 1 ve Gemini 3.5 Flash-Lite ile bir bankacılık niyet sınıflandırıcı oluşturduk; ardından iki modeli karşılaştırmak için doğruluk, gecikme, kalibrasyon ve maliyeti hesapladık. İşte eğitimden dört çıkarım:

  • Doğruluk berabere: Decision 1 için %84,4 ve Flash-Lite için %83,9; 180 mesajın 163’ünde aynı hüküm.
  • Decision 1 daha hızlı ve daha öngörülebilirdi: Ortanca gecikmesi 325 ms iken Flash-Lite 1.068 ms; en yavaş istek 1,0 s iken 101,6 s.
  • Decision 1’in güveni kullanılabilirdi: ECE 0,050 iken 0,124; eşiğin 0,9’a yükseltilmesi, tutulan yanıtlarda doğruluğu %84,4’ten %95,6’ya çıkardı. Flash-Lite’ın kendi bildirdiği güven, doğru ve yanlışları pek ayıramadı.
  • Maliyet ve ölçekleme, soruları nasıl yazdığınıza bağlıdır: Decision 1 tekil mesajlarda 4,3x daha ucuzdu; ancak her soru seçenek açıklamaları için ödeme yapar. Bu nedenle toplam girdiyi yaklaşık 16K tokenın altında tutun ve seçenek açıklamalarını kısa tutun.

Bu sonuçlar, bir görev, bir veri kümesi ve bir Colab defterinden sınırlı sayıda çalıştırmadan gelmektedir. Bunları genel performans iddiaları yerine bir demodan gözlemler olarak değerlendirebilirsiniz. 

Aashi Dutt

Yazar

Aashi Dutt

ML (Üretken Yapay Zekâ) alanında Google Developers Uzmanıyım, Kaggle 3x Expert unvanına sahibim ve 3+ yıllık teknoloji deneyimiyle Women Techmakers Elçisiyim. 2020'de bir sağlık teknolojileri girişiminin kurucu ortağı oldum ve Georgia Tech'te makine öğrenmesi alanında uzmanlaşarak bilgisayar bilimleri yüksek lisansı yapıyorum.

SSS

Decisions API ile üretken bir API arasındaki fark nedir?

Üretken bir API yanıtını token token yazar ve her çıktı tokenını ücretlendirir. Decisions API ise sabit bir seçenek kümesini tek bir ileri geçişte puanlar ve her biri için bir olasılık döndürür. Çıktı tokenı üretmez; bu yüzden yalnızca girdi için ödeme yaparsınız.

Gemini Decision 1, Gemini 3.5 Flash-Lite’tan daha mı doğru?

Bizim testimizde hayır. 180 bankacılık mesajında, doğruluk Decision 1 için %84,4 ve Flash-Lite için %83,9 idi. Ölçtüğümüz farklar gecikme, kalibrasyon ve maliyetteydi.

Decision 1 neden Flash-Lite’tan daha fazla girdi tokenı kullanıyor?

Her sorunun yönergesi ve seçenek açıklamaları girdi olarak sayılır. 12 açıklamalı seçenekle, testimizde soru başına yaklaşık 300 token ekledi. Kısa veya boş seçenek açıklamaları bunu azaltır.

Daha fazla soru ekledikçe gecikme sabit mi kalır?

Bizim çalıştırmalarımızda ortanca, 50 soruya kadar 650 ms’nin altında kaldı. 12 tam seçenek açıklamasıyla 100 soruda istek yaklaşık 30 bin tokena ulaştı ve 48 ila 59 s sürdü. Boş açıklamalarla aynı 100 soru yaklaşık 16 bin tokena sığdı ve 1,6 s sürdü.

Decisions API hangi soru türlerini destekler?

Decisions API üç soru türünü destekler: evet/hayır kontrolleri için noul, 2 ile 255 arasından bir seçeneği seçmek için choice ve sıralı bir rubriğe göre notlamak için score. Üçünü de tek bir istekte karıştırabilirsiniz.

Konular

İlgili