Context Window, Tokenlar ve Fatura: Ölçülmüş

Bu işteki en pahalı yanlış kanı, bir modelin konuşmayı hatırladığıdır.

Hatırlamaz; Bölüm 13’teki mekanizma bunun nedenini tam olarak söyler. Üretim sırasında bir transformer’ın durumu KV cache’tir: dizideki her token için hesaplanan key ve value’lar. Bu cache tek bir request süresince yaşar. Request bittiğinde, onu tutan süreç başka birine hizmet vermekte serbesttir ve cache gitmiştir. Diğer tarafta kullanıcı başına bir store yoktur, session da yoktur.

Bu yüzden bir sonraki request, modelin bilmesi gereken her şeyi taşıyarak gelmek zorundadır ve model, tek bir yeni token yaymadan önce tüm prompt üzerinde forward pass çalıştırarak bu durumu yeniden kurar. Bölüm 15 prompt’u “tüm durum” diye adlandırmıştı. Fiziksel neden budur: prompt eksiksiz durumdur, çünkü çağrıdan geriye başka hiçbir şey kalmaz.

Context window, o prompt artı yanıtının maksimum uzunluğudur. Yeniden kurabileceğin durum miktarı için bir tavandır; request’ler arasında herhangi bir şeyi tutan bir kap değildir. Buna “modelin belleği” demek nedenselliğin yönünü tersine çevirir — bir belleği doldurmuyorsun, bir belleği yeniden kurmak için ödeme yapıyorsun.

Yirmi ikinin geldiği yer burasıdır. $n$ numaralı tur, önceki $n-1$ turun tamamını taşır; bu yüzden $n$ turluk bir konuşmada toplam input, büyüyen bir serinin toplamıdır ve bu ikinci derecedendir:

burada $s$ system prompt, $h_i$ ise $i$ turundaki history’dir. Kırk tur boyunca ölçülen kümülatif input’u $an^2 + bn$ üzerine oturtunca $60.22\,n^2 + 432.25\,n$ çıkar; bu, 40. turda ölçülen 112.617 token’a karşı 113.645 token öngörür. İkinci dereceden terim baskındır; doğrusal terim ise kullanıcının gerçekten yazdığı şeydir.

Bu bölümden akılda kalması gereken sonuç şudur: faturan son soruyla değil, konuşmanın karesiyle büyür. Aynı kırk soru hiç history olmadan sorulsaydı $0.066036 tutardı. History’yi tutmak $0.274386 tuttu. History faturayı 4,2 ile çarptı ve çarpmaya devam edecek, çünkü çarpan konuşma uzunluğudur.

Pencere, aynı yöne çeken iki nedenle sonludur. İlki Bölüm 9’un nedenidir: attention her token’ı diğer tüm tokenlarla karşılaştırır, dolayısıyla o katmanın işi sequence length’in karesiyle büyür. İkincisi bellektir: KV cache, sequence length ile doğrusal büyür ve Bölüm 13 bu hesabı yaptı — uzun dizilerde ağırlıklardan daha büyük hale gelir.

Her iki limite de saldırıldı, fakat hiçbiri ortadan kalkmadı. FlashAttention¹, hesaplamayı high-bandwidth memory’ye çok daha az okuyup yazacak şekilde yeniden düzenler; bu, asimptotik maliyeti değiştirmeden uzun dizileri pratik kılar. Position Interpolation² ve YaRN³, Bölüm 9’daki positional encoding’leri yeniden ölçekleyerek, yeniden eğitim yerine eğitilmiş bir modelin kullanılabilir penceresini genişletir. Pencerelerin beş yılda 2K’dan 1M’ye çıkmasının nedeni birlikte bunlardır.

Yapmadıkları şey, uzun context’leri ücretsiz hale getirmekti. Tavanı yükselttiler ve eğimi yumuşattılar. Eğim hâlâ orada ve bu bölümün ilerleyen kısımlarındaki fiyat kademeleri bunu ölçüyor.

İnternetteki neredeyse her maliyet hesaplayıcısı bir API çağrısını input tokenları çarpı input fiyatı artı output tokenları çarpı output fiyatı olarak modeller. Bu 2023’te doğruydu. Artık, faturaları iki yönde de iki kat veya daha fazla saptıracak şekilde yanlış.

Beş faturalandırılabilir token kategorisi vardır:

Bu beşin üçü iki yıl önce ayrı satırlar olarak yoktu; iki cache satırı ise insanların yanlış anladığı satırlar, çünkü bir cache write sıradan input’tan daha pahalıdır, daha ucuz değil. Bir şeyi saklamak için prim ödersin ki sonra onu indirimli okuyabilesin; bunun iyi bir takas olup olmadığı tamamen onu kaç kez okuduğuna bağlıdır.

Reasoning kovası Bölüm 12’nindir, artık üzerinde fiyat etiketiyle, ve açıkça söylenmeye değer bir ayrıntı taşır: Google dokümantasyonu pricing’in “API’den yalnızca özet output edilse de modelin üretmesi gereken tam thought tokenları temelinde” olduğunu söyler.⁴ Sana hiç iletilmeyen tokenlar için faturalandırılırsın. İçeriğini sayamadığın, inceleyemediğin veya doğrulayamadığın tek kova budur.

Şimdi bunu bir çarpma problemi olmaktan çıkarıp normalisation problemine dönüştüren kısım. Her sağlayıcı bu kovaları farklı adlarla raporlar ve — tuzak bu — ikisi aynı kelimeyi iki farklı nicelik için kullanır.

Bir çağrı al: cache’ten okunan 4.837 token, 110 taze token, 142 görünür output token, 300 reasoning token.

// OpenAI-compatible
{ "usage": { "prompt_tokens": 4947,
             "prompt_tokens_details": { "cached_tokens": 4837 },
             "completion_tokens": 442,
             "completion_tokens_details": { "reasoning_tokens": 300 } } }

// Anthropic
{ "usage": { "input_tokens": 110,
             "cache_read_input_tokens": 4837,
             "cache_creation_input_tokens": 0,
             "output_tokens": 442 } }

// Gemini
{ "usageMetadata": { "promptTokenCount": 4947,
                     "cachedContentTokenCount": 4837,
                     "candidatesTokenCount": 142,
                     "thoughtsTokenCount": 300 } }

prompt_tokens: 4947 ve input_tokens: 110 alanlarına bak. İki alan da aynı prompt için input token sayısıdır. OpenAI’ninki cached tokenları içerir; Anthropic’inki onları hariç tutar — dokümantasyonu kimliği açıkça yazar, total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens.⁵ Anthropic’in input_tokens alanı “son cache breakpoint’inden sonraki tokenlar” demektir.

Output’a da bak. OpenAI ve Anthropic ikisi de 442 raporlar; bu sayı zaten 300 reasoning tokenı içerir. Gemini 142 raporlar ve 300’ü ayrı bir alana koyar. Bölüm 12 bunu aynı işi saymanın iki yolu arasındaki uyumsuzluk olarak işaretlemişti; işte maliyeti.

Bir normaliser otuz satırdır ve opsiyonel değildir:

export interface Usage {
  promptTokens?: number;        // input, NOT cached
  cachedInputTokens?: number;   // read from cache
  cacheWriteTokens?: number;    // written to cache on this call
  completionTokens?: number;    // output
  reasoningTokens?: number;     // billed apart from output (Gemini only)
}

const num = (v: unknown) => (typeof v === "number" && isFinite(v) ? v : 0);

export const fromOpenAI = (raw: any): Usage => {
  const u = raw.usage ?? {}, d = u.prompt_tokens_details ?? {};
  const cached = num(d.cached_tokens), write = num(d.cache_write_tokens);
  return {
    promptTokens: Math.max(0, num(u.prompt_tokens) - cached - write), 
    cachedInputTokens: cached,
    cacheWriteTokens: write,
    completionTokens: num(u.completion_tokens),   // reasoning already inside
    reasoningTokens: 0,
  };
};

export const fromAnthropic = (raw: any): Usage => {
  const u = raw.usage ?? {};
  return {
    promptTokens: num(u.input_tokens),            // already excludes cache
    cachedInputTokens: num(u.cache_read_input_tokens),
    cacheWriteTokens: num(u.cache_creation_input_tokens),
    completionTokens: num(u.output_tokens),
    reasoningTokens: 0,
  };
};

export const fromGemini = (raw: any): Usage => {
  const m = raw.usageMetadata ?? {}, cached = num(m.cachedContentTokenCount);
  return {
    promptTokens: Math.max(0, num(m.promptTokenCount) - cached),
    cachedInputTokens: cached,
    cacheWriteTokens: 0,
    completionTokens: num(m.candidatesTokenCount), // EXCLUDES thinking
    reasoningTokens: num(m.thoughtsTokenCount),    // billed at output rate
  };
};

Yukarıdaki üç payload’u üç reader’dan geçirince üçü de aynı Usage değerini ve dolayısıyla aynı sayıyı üretir: $0.006491. Katmanı yazmanın tüm amacı bu uzlaşıdır.

Yanlış yaparsan aynı çağrıda maliyeti şudur:

Üçüncüsü tehlikelidir, çünkü iyi haber yönünde sessizce bozulur. Dashboard’un bir reasoning modelinin gerçek maliyetinin yarısından az tuttuğunu gösterir ve hiçbir yerde hata yükselmez.

Kovalar normalise edilince cost function kısadır. Tek bariz olmayan kısım, sonraki bölümün açıkladığı tier lookup’tır:

export interface Tier { maxPromptTokens: number | null; price: number }
export interface Pricing {
  input: Tier[]; output: Tier[];
  cachedInput?: Tier[]; cacheWrite?: Tier[]; reasoning?: Tier[];
}

const tierPrice = (tiers: Tier[] | undefined, contextSize: number, fallback?: Tier[]) => {
  const table = tiers ?? fallback;
  if (!table?.length) return 0;
  const sorted = [...table].sort(
    (a, b) => (a.maxPromptTokens ?? Infinity) - (b.maxPromptTokens ?? Infinity));
  for (const t of sorted)
    if (t.maxPromptTokens === null || contextSize <= t.maxPromptTokens) return t.price;
  return sorted[sorted.length - 1].price;
};

export function computeCost(pricing: Pricing, usage: Usage): number {
  const fresh = usage.promptTokens ?? 0;
  const read  = usage.cachedInputTokens ?? 0;
  const write = usage.cacheWriteTokens ?? 0;
  const out   = usage.completionTokens ?? 0;
  const think = usage.reasoningTokens ?? 0;
  const contextSize = fresh + read + write;   // the tier depends on the WHOLE prompt
  return fresh * tierPrice(pricing.input, contextSize)
       + read  * tierPrice(pricing.cachedInput, contextSize, pricing.input)
       + write * tierPrice(pricing.cacheWrite,  contextSize, pricing.input)
       + out   * tierPrice(pricing.output, contextSize)
       + think * tierPrice(pricing.reasoning, contextSize, pricing.output);
}

Oradaki iki tasarım kararını savunmaya değer. Fallback’ler — cache fiyatlarının input’a, reasoning’in output’a düşmesi — eksik bir tablonun ne anlama geldiğini kodlar: Gemini’de reasoning tokenları output oranından faturalandırılır; bu yüzden eksik bir reasoning fiyatı sıfır değildir, output fiyatıdır. Ve contextSize yalnız taze olanları değil, üç input kovasının tümünü toplar; çünkü tier, prompt’un ne kadar uzun olduğuna göre seçilir, ne kadarının tam fiyatla ücretlendirildiğine göre değil.

Prompt caching, prompt’unun bir prefix’i için modelin hesaplanmış durumunu depolar; böylece aynı prefix’e sahip daha sonraki bir request onu yeniden hesaplamayı atlar. “Prefix” kelimesinden dört özellik çıkar ve dördü de insanları şaşırtır.

Break-even akılda tutulacak kadar küçüktür ve OpenAI dokümantasyonu hesabı yapar: bir prefix’i bir kez yazıp bir kez reuse etmek, sıradan input maliyetinin 1.35×’ine mal olur; aynı şeyi iki kez uncached işlemek 2×’dir. On request boyunca bir write ve dokuz read 2.15× tutar; uncached 10×. Bir reuse write’ın parasını çıkarır. Anthropic de aynı yere iner: beş dakikalık cache için bir read, bir saatlik cache için iki read.

Şimdi kırk turluk konuşma tekrar, caching açık ve prefix stabil halde:

Yüzde altmış sekiz daha ucuz ve bu tablodaki üç sayı dikkatini geri öder.

Cache 6. tura kadar devreye girmez. Prompt o zamana kadar 1.024 token’a ulaşmaz; bu yüzden ilk beş tur tam olarak eskisi gibi faturalandırılır — altıncı tur ise cache’i dolduran tur olduğu için 1.25× write primiyle daha kötü faturalandırılır. İlk read 7. turda gelir. Tablodaki 2.887 uncached token hesabı budur: altı değil, beş turun karşılığı. Caching uzun prompt’larda indirimdir; kısa bir konuşma bundan hiçbir şey almaz.

Write primi $0.002474, yani cached faturanın %2,8’i. Her tur yeni kuyruğunu yazar, kırk kez, ve tüm write primi read’lerin kazandırdığının yanında yuvarlama hatasıdır. Write ücretini tam anlamak, onun için endişelenmeyi bırakman içindir.

112.617 içinden yalnızca 2.887 token tam input fiyatıyla ücretlendirildi. Çalışan bir cache’in şekli budur: neredeyse her şey read’dir.

Gerçek para yakan hata burada ve tek satırlık bir bug.

Her çağrıda değişen bir şeyi prompt’un başına koy — timestamp, request id, kullanıcının adı, “bugün” satırı, yeni retrieve edilmiş bir belge — ve prefix ilk byte’tan itibaren farklılaşır. Hiçbir şey eşleşmez. Her çağrı miss olur. Ve her çağrı yeni bir prefix sunduğu için her çağrı ayrıca write yapar.

Aynı konuşma, aynı kırk tur, caching açık, system prompt’un tepesinde çağrı başına timestamp ile:

Prompt caching’i etkinleştirmek konuşmayı, etkinleştirmemekten yüzde yirmi daha pahalı hale getirdi. 109.730 token üzerinde 1.25× write primini ödedin ve sıfırını geri okudun. Hata yok, uyarı yok ve özellik açık.

Kural, yani prompt caching’in tamamı tek satırda: stabil içerik önde, değişken içerik arkada. Önce system instructions, tool definitions ve referans materyali; en sonda timestamp’ler, kullanıcı kimliği ve mevcut soru. Anthropic hiyerarşiyi açık eder — cache tools → system → messages sırasını izler; herhangi bir seviyedeki değişiklik o seviyeyi ve sonrasındaki her şeyi invalidates eder, bu yüzden tek bir tool açıklamasını düzenlemek tüm cache’i invalidates eder.⁵

İnsanların takıldığı iki sonuç var. Hangi tools’un enabled olduğunu değiştirmek tool definitions’ı değiştirir; dolayısıyla bazı kullanıcılar için tool ekleyen bir feature flag cache’ini ikiye böler. Anthropic’te web search veya citations toggle etmek system prompt’u değiştirir; kendi metninin tek satırına dokunmasan bile system ve message cache’lerini invalidates eder.

İkinci dereceden büyüyen faturaya verilen bariz yanıt, tüm history’yi göndermeyi bırakmaktır: son bir düzine mesajı tut, gerisini at. Bu faturayı düşürür; genellikle yanlış hamledir ve ölçüm nedenini söyler.

On iki mesajlık pencereye kırpmak, her şeyi uncached göndermekten %57 ucuzdur — herkesin yaptığı karşılaştırma bu ve tekniğin popüler olmasının nedeni de bu. Ama çalışan bir cache ile her şeyi göndermekten %39 daha pahalıdır ve truncation yanında caching’i açmak daha iyi değil, biraz daha kötü yapar.

Mekanizma yine prefix’tir. Sliding window her tur en eski mesajı düşürür; bu yüzden prompt artık geçen sefer başladığı yerden başlamaz ve her tur yeni bir prefix sunar. OpenAI’ın rehberi tam bunu söyler: “summarisation, compaction, or context truncation can change the prefix and reset cache reuse.”⁶ 40. turda windowed prompt 813 token’dır, 1.024-token minimumun altındadır; dolayısıyla hiç cache’lenemez.

Ve para, maliyetin ucuz yarısıdır. Attığın şey, kullanıcının 2. turda verdiği ve modelin 40. turda ihtiyaç duyduğu talimattır. Truncation görünür bir faturayı görünmeyen bir arızayla takas eder; bunu doğru yapmak — compaction, pencere dışında tutulan structured notes, history’yi ihtiyaç anında retrieve etmek — Bölüm 24’ün konusudur.

Uzun context’ler yalnızca daha uzun oldukları için pahalı değildir. Bir eşikten sonra token başına daha pahalıdırlar ve eşik geriye dönük olarak tüm prompt’a uygulanır.

OpenAI’ın gpt-5.6-terra için model sayfası bunu tek cümleyle söyler: “Prompts with >272K input tokens are priced at 2x input and 1.5x output for the full request.”⁷ Fazlalık için değil. Tüm şey için.

prompt 271,999 + 500 output  ->  $0.5500
prompt 272,000 + 500 output  ->  $0.5500
prompt 272,001 + 500 output  ->  $1.0970

Bir token, elli beş sent. Servisin prompt’ları boyutunu kontrol etmediğin retrieved belgelerden kuruyorsa, maliyet modelinde ekibindeki kimsenin yazmadığı bir sınırda uçurum var demektir.

Google’ın pricing’i de 200.000-token eşiğiyle aynı şekilde çalışır: Gemini 2.5 Pro, 200K’ya kadar prompt’lar için milyon input token başına $1.25, üstünde $2.50’dir; output $10.00’dan $15.00’a çıkar.⁸ Anthropic ters yöne gitti — 6 Eylül 2026 itibarıyla dokümantasyonu Claude 4.6 ve sonrası için tam bir milyon-token window’un standard pricing’e dahil olduğunu söyler; yani “900k-token request is billed at the same per-token rate as a 9k-token request.”⁹ Daha eski modeller surcharge tutuyordu.

Bu yüzden price bir sayı değildir. Price, prompt length ile anahtarlanan bir tier tablosudur; cost function’daki Tier[] bunun içindir ve computeCost bu yüzden tier’ı her kovaya ayrı ayrı göre değil, tüm prompt’u kullanarak seçer.

Beş kova Bölüm 13’teki iki faza eşlenir; eşlemeyi gördüğünde fiyat oranları keyfi görünmeyi bırakır.

Input tokenları prefill’dir. Tüm prompt modelden tek pass’te geçer, paralel işlenir — büyük matrix multiplications, compute-bound. Token başına maliyet düşüktür ve time to first token değerini belirleyen faz budur: 4.947-token prompt’ta ilk kelime görünmeden önce yapılacak 4.947 token prefill vardır.

Output tokenları decode’dur. Tek tek üretilirler; her biri tüm KV cache’i okuyan tam bir forward pass’tir ve GPU çoğunlukla hesaplamak yerine belleği bekler. Tokens per second değerini belirleyen faz budur; tek response içinde paralelleştirilemez ve burada fiyatlanan modelde output’un input’tan yaklaşık altı kat pahalı olmasının nedeni budur: milyon token başına $12.00’a karşı $2.00.

Üç sonuç doğrudan buradan çıkar. Cache read prefill işinin yerini alır, yani latency ve parayı aynı anda satın alır — aynı indirim daha düşük fatura ve ilk token için daha kısa bekleme olarak görünür. Reasoning tokenları görmediğin decode’dur, bu yüzden reasoning modeli birkaç saniye hiçbir şey stream etmez, sonra hızlı yanıtlar: Bölüm 12 arayüz sonucuna dikkat çekmişti, bu da fatura sonucudur. Ve stream’i abort etmek generation’ı durdurmaz — Bölüm 14 cancellation’ı kurdu ve fiyatı bu bölüme bıraktı; fiyat tam output count’tur, çünkü tokenlar üretilir ve kimse dinlemese de faturalandırılır. Kimsenin tutmadığı yanıt için de aynısı geçerlidir: 40. tur yanıtını beş kez yeniden üretmek, ekranda kalan tek yanıt için $0.057990 tutar.

Bölüm 7’nin tokenizer’ı Python’dı ve orada kaldı. Bütçeleme request’i kuran server’da olur; dolayısıyla burada olmak zorunda ve tam üç doğruluk seviyesi vardır.

Seviye bir: yerelde say. js-tiktoken, Python tiktoken ile aynı BPE merge tablolarını taşır; böylece OpenAI encodings için ağ çağrısı olmadan byte-for-byte aynı sayım verir:

import { getEncoding } from "js-tiktoken";

const enc = getEncoding("o200k_base");
const PER_MESSAGE = 4;   // role and delimiters added by the chat template
const PER_REPLY = 3;     // priming for the assistant turn

export function promptTokens(messages: { role: string; content: string }[]) {
  return messages.reduce(
    (sum, m) => sum + enc.encode(m.content).length + PER_MESSAGE, PER_REPLY);
}

İki sabit önemlidir ve yerel sayımların kaydığı yer burasıdır. Tokenize edilen şey senin metnin değildir — Bölüm 11’deki chat template önce her mesajı role marker’larıyla sarar ve bunlar ödediğin tokenlardır. Mesaj başına dört ve reply priming için üç, OpenAI chat modelleri için geleneksel yaklaşımdır; yukarıdaki konuşmanın seksen bir mesajında toplam 324 token eder, uzunluğunun %6,4’ü. Buradaki sayımlar tüm seksen bir string üzerinde Bölüm 7’deki Python tiktoken ile çapraz kontrol edildi ve aynıdır.

Seviye iki: sağlayıcıya sor. Anthropic /v1/messages/count_tokens, Google ise count_tokens sunar; ikisi de gerçek çağrıyla aynı request shape’i kabul eder ve ücretsiz input token count döndürür. Yerelde sayamadığında kullan — Anthropic için yerelde sayamazsın, çünkü tokenizer’ı yayınlanmış değildir. Anthropic dokümantasyonu sana ne verdiği konusunda dikkatli: count “is an estimate” ve “may include tokens added automatically by Anthropic for system optimizations”; bunlar için “you are not billed”.¹⁰

Seviye üç: response’taki usage değerini oku. Gerçek budur ve para harcandıktan sonra gelir. İlk iki seviyenin var olma nedeni tam olarak budur — request’i gönderip göndermemeye karar vermek, faturalandırmak değil.

Satır kalemi olarak görünmeyen dört satır kalemi.

Her çağrıda ödenen system prompt. Yukarıdaki, template overhead ile 192 token. Kırk çağrıda 7.680 token eder — bir kez yazılmış sekiz satır için bu konuşmanın tüm faturasının %5,6’sı. Ayrıca hem stabil hem ilk olduğu için mümkün olan en iyi cache adayıdır.

Tool definitions. Her tool’un adı, açıklaması ve JSON schema’sı her request’te gider; sağlayıcılar üstüne scaffolding ekler. Anthropic sayıyı yayınlar: tools’u etkinleştirmek bile Claude Sonnet 4.5’te tool_choice değeri auto iken 496 tokenlık gizli system prompt ekler; any veya named tool ile 588 token.⁹ Bu, senin kendi schema’larından öncedir. Bölüm 18 catalogue’u kurar; Bölüm 24 ne yediğini ölçer.

Attıkların dahil her generation. Beş regeneration beş kat tutar. Chat birini gösterir.

Sana gösterilmeyen thoughts. Billing yalnızca özet dönse de tam thought tokenlarına dayanır ve senin muhaseben bu sayıyı audit edemez.

Kapanış için bir uyarı; çünkü doğal bir sonraki düşünce bu ve yanıt bariz olan değil.

Milyon-token window, milyon kullanılabilir token demek değildir. Retrieval accuracy konuma göre düşer: Liu ve arkadaşları, modellerin uzun input’un başındaki ve sonundaki bilgiyi güvenilir biçimde bulduğunu, ortadakini ise çok daha az güvenilir bulduğunu gösterdi.¹¹ Daha büyük pencere daha fazlasını gönderme yeteneği satın alır, okunma kesinliğini değil.

Bu fenomen bu kursta bir kez ölçülür — aynı 853-token prompt’ta dokuz konumdaki retrieval rate — ve bir agent’ın ne yaptığını değiştirdiği Bölüm 24’e aittir. Burada alıntılanmasının nedeni, ne satın alman gerektiğini değiştirmesidir: en ucuz token, göndermediğindir.

Artık bir çağrıyı yapmadan önce neye mal olacağını tahmin edebilir, sonra gerçekten ne tuttuğunu okuyabilir ve ikisinin farkını söyleyebilirsin. Bu, request hakkında henüz dokunmadığın kısım dışında her şeyi kapsar: düğmeler.

Bölüm 17 sampling — temperature, top-p, top-k, penalties ve sahip olmadığın determinism. Alandaki en yaygın hatayı, temperature’ın yaratıcılık kadranı olduğu fikrini yıkarak başlar. Değildir: temperature, Bölüm 4’teki logits’i softmax öncesinde böler; onu yükseltmek modeli hayal gücü yüksek yapmaz, modelin kendisinin daha kötü puanladığı tokenların olasılığını yükseltir. Buradan, greedy decoding’in neden sampling’den ölçülebilir şekilde daha kötü metin ürettiğine, top-k ve top-p’nin distribution’ın zıt şekillerinde neden başarısız olduğuna ve bölümü bitiren deneye gider: temperature 0’da yirmi identical forward pass, model tek başına çalıştığında bit-for-bit aynı döner; aynı prompt’u başkasının request’leriyle birlikte batch’e koymak logits’lerinin %97’sini oynatır.

Hepsi eşleşmez. Neden, Bölüm 2’deki floating-point kutusuyla başlar.

Bu bölümdeki tüm fiyatlar, thresholds ve multipliers sağlayıcıların kendi sayfalarından 6 Eylül 2026 tarihinde okunmuştur ve değişecekleri için bu tarihle belirtilmiştir. Yöntem sayılardan daha önemlidir: kovalar, prefix kuralı ve tier aritmetiği iki yıldır stabilken içlerindeki her rakam hareket etmiştir.

Stanford CS336 lecture 2, Resource accounting, bu malzemenin en yakın akademik ele alınışıdır ve doğru sonraki okumadır: bu bölümün inference tarafında yaptığı aynı aritmetiği training tarafında yapar. Buradaki token sayımları, 5.090 tokenlık kırk turluk konuşma üzerinde o200k_base ve cl100k_base encodings kullanılarak js-tiktoken 1.0.21 ile üretildi; message başına template overhead geleneksel four-plus-three approximation’dır ve dahil olduğu her yerde belirtilmiştir. Cache, tier ve truncation rakamları, ölçülen token sayımlarına uygulanmış belgelenmiş pricing kurallarıdır; live API response gözlemleri değildir — bu bölümü üretmek için ücretli çağrı yapılmadı; latency iddialarının qualitative, cost iddialarının ise qualitative olmamasının dürüst nedeni de budur.