Multimodální ceny: za co se u obrázků, audia a videa opravdu účtuje

Transformer přijímá sekvenci vektorů. Nezajímá ho, odkud přišly. Kapitola 8 mu předávala embeddings vyhledané podle token id; nic v architektuře nevyžaduje vyhledávání.

Takže: rozřežte obrázek na pevné čtverce, každý čtverec zploštěte na seznam čísel a každý seznam pošlete přes jednu naučenou lineární vrstvu, abyste získali vektor šířky modelu. Barevný patch pixelů 32 × 32 je $32 \times 32 \times 3 = 3072$ čísel; projekce $E \in \mathbb{R}^{d \times 3072}$ z něj udělá jeden $d$-rozměrný vektor, přesně ve tvaru, v jakém přichází textový token. To je celé, a přesně to říká název článku: obrázek má hodnotu 16 × 16 slov.¹ Přidejte poziční kódování, aby model věděl, který čtverec byl kde, proložte výsledky textovými embeddings, a sekvence, kterou model čte, je zčásti obrázek a zčásti věta.

Tři články z toho udělaly produkt. CLIP natrénoval image encoder a text encoder tak, aby se shodly na čtyř stech milionech scrapovaných dvojic; tam přestala být myšlenka, že pixely a slova mohou sdílet prostor, hypotézou.² Flamingo připevnilo zmrazený vision encoder ke zmrazenému jazykovému modelu pomocí několika natrénovaných přemosťovacích vrstev.³ LLaVA ukázala, že mostem může být jediná lineární projekce a instruction-following lze naučit na generovaných datech; proto od té doby každý otevřený vision-language model vypadá zhruba stejně.⁴

Důsledek pro vaši fakturu je okamžitý a neokázalý: patches jsou pozice v sekvenci, takže jsou input tokens, takže za ně platíte vstupní sazbu. Kolik jich je, to je aritmetika, a každý provider ji dělá jinak.

Každé pravidlo níže je implementované z vlastní dokumentace providera a ověřené proti vypracovaným příkladům ve stejné dokumentaci.

OpenAI pokryje obrázek patchi 32 × 32 a počet vynásobí faktorem podle modelu. Pokud počet patchů překročí rozpočet pro daný model a úroveň detailu, obrázek se zmenšuje, dokud se nevejde:

Anthropic ho pokryje patchi 28 × 28, jeden visual token každý, a omezuje jak dlouhou hranu, tak počet tokenů — 1 568 pixelů a 1 568 tokenů u modelů standardní úrovně, 2 576 a 4 784 u high-resolution úrovně. Příliš velké obrázky se zmenší na největší velikost, která splní obě podmínky.⁵

Google pixely nepočítá vůbec. Obrázek, jehož obě strany mají nejvýše 384 pixelů, stojí paušálně 258 tokenů. Cokoli většího se řeže na tiles po 258 tokenech a mřížka tiles vychází z crop unit $\lfloor \min(w,h) / 1.5 \rfloor$.⁶

export function openaiImageTokens(
  w: number, h: number,
  { maxDim, patchBudget, multiplier }: { maxDim: number; patchBudget: number; multiplier: number },
) {
  const fit = Math.min(1, maxDim / Math.max(w, h));      // never enlarges
  w = Math.floor(w * fit); h = Math.floor(h * fit);
  let patches = Math.ceil(w / 32) * Math.ceil(h / 32);   
  if (patches > patchBudget) {
    const s = Math.sqrt((32 * 32 * patchBudget) / (w * h));
    const adj = s * Math.min(
      Math.floor((w * s) / 32) / ((w * s) / 32),
      Math.floor((h * s) / 32) / ((h * s) / 32));
    patches = Math.ceil(Math.floor(w * adj) / 32) * Math.ceil(Math.floor(h * adj) / 32);
  }
  return Math.ceil(patches * multiplier);                
}

export function anthropicVisualTokens(
  w: number, h: number,
  { maxLongEdge, maxTokens }: { maxLongEdge: number; maxTokens: number },
) {
  const tok = (a: number, b: number) => Math.ceil(a / 28) * Math.ceil(b / 28);
  const long = Math.max(w, h), short = Math.min(w, h);
  for (let L = Math.min(long, maxLongEdge); L >= 1; L--) {     
    const t = tok(L, Math.round((short * L) / long));
    if (t <= maxTokens) return t;                              
  }
  return 0;
}

export function geminiImageTokens(w: number, h: number) {
  if (w <= 384 && h <= 384) return 258;
  const crop = Math.floor(Math.min(w, h) / 1.5);               
  return Math.ceil(w / crop) * Math.ceil(h / crop) * 258;      
}

Spusťte každé pravidlo proti číslům, která tiskne jeho vlastní vendor:

OpenAI, gpt-5.4 at detail:high (2048 px, 2,500 patches, 1.2x)
  1024x1024 -> 1024 patches -> 1229 tokens   doc says 1229   MATCH
  2048x2048 -> 2500 patches -> 3000 tokens   doc says 3000   MATCH

Anthropic, the published table (one tier per row shown)
  200x200    std   64 @ 200x200     doc   64, not resized    OK
  1000x1000  std 1296 @ 1000x1000   doc 1296, not resized    OK
  1092x1092  std 1521 @ 1092x1092   doc 1521, not resized    OK
  1920x1080  std 1560 @ 1456x819    doc 1560, 1456x819       OK
  2000x1500  std 1564 @ 1269x952    doc 1564, 1269x952       OK
  3840x2160  hi  4784 @ 2576x1449   doc 4784, 2576x1449      OK

Google, the worked example
  960x540 -> crop 360 -> 3 x 2 = 6 tiles     doc says 6      MATCH

Vytištěno je devět shod; celý běh kontroluje patnáct, protože Anthropicova tabulka uvádí obě úrovně pro všech šest velikostí. Pravidla teď můžete spustit na jakékoli své fotografii, a o to jde: tohle jsou jediné tři funkce v této kapitole, které nedostanete z cenové stránky.

Pošlete stejnou fotografii 4:3 přes všechny tři systémy v šesti velikostech:

Čtěte poslední sloupec dolů. Jakmile je obrázek nad 384 pixelů, číslo se už nikdy nezmění, a není to náhoda ani strop. Dosaďte crop unit zpět do tile vzorce pro obrázek alespoň tak široký jako vysoký:

Velikost se vykrátí. Google image tokens závisí na poměru stran a na ničem jiném. Fotografie 4:3 jsou čtyři tiles, ať je to thumbnail nebo plakát. Tento jediný algebraický fakt je celé vysvětlení nuly v tabulce úspor výše, a žádná cenová stránka ho nikde neříká.

Další dva sloupce místo toho narážejí na strop, v různých výškách a z různých důvodů — Anthropic na deklarovaný token ceiling, OpenAI na patch budget po pixel limitu — proto se tři křivky protínají u různých velikostí.

Teď to rozbijte. Zjevný způsob, jak za vision model utratit méně, je požádat o méně detailu, takže pošlete detail: "low":

1600x1200   low = 2280   high = 2280   ratio 1.00
3200x2400   low = 3687   high = 2942   ratio 1.25

Požadavek na méně detailu stál o 25 % víc. Není to chyba a OpenAI to říká jedním řádkem v tabulce velikostí: u této rodiny modelů používá low limit 2048 pixelů s rozpočtem 6 144 patchů, zatímco high používá stejný pixel limit s rozpočtem 2 500 patchů, „takže může použít více tokenů než high“.⁷ Slovo low pojmenovává nastavení věrnosti, ne cenu: u dvou z pěti zdokumentovaných rodin modelů nepřináší žádnou úsporu a u jedné z těch dvou stojí víc.

Všechno doposud byl model, který obrázek čte. Vytvořit obrázek běží na mechanismu, v němž nejsou žádné tokeny, a právě proto se prodává za obrázek, ne za slovo.

Vendoři zveřejňují generování obrázků jako cenu za obrázek. Tou ale není. GPT Image modely emitují specializované image tokens, jejichž počet závisí na požadované velikosti a kvalitě; vynásobte zveřejněné počty publikovanou výstupní sazbou GPT Image 1 ve výši $40 za milion a porovnejte s cenami za obrázek na stejné stránce:

Devět odvozených čísel proti devíti zveřejněným, každý pár se shodou do $0.002.¹¹ Google je ještě explicitnější a převod dělá za vás přímo na cenové stránce: image output za $60 za milion tokenů, „výstupní obrázky v 1K (1024x1024px) spotřebují 1120 tokenů a odpovídají $0.067 za obrázek“.¹²

Cena za obrázek je tedy cena za token se zahrnutým počtem. To je v pořádku, a něco to skrývá. Vezměte tabulku aktuální generace a vydělte zpětně:

quality   1024x1024            1024x1536
low       $0.006 -> 200 tok    $0.005 -> 167 tok
medium    $0.053 -> 1767 tok   $0.041 -> 1367 tok
high      $0.211 -> 7033 tok   $0.165 -> 5500 tok

Větší obrázek je levnější při každé kvalitě. Canvas 1024 × 1536 má o 50 % víc pixelů než 1024 × 1024 a při medium stojí o 23 % méně tokenů. OpenAI to označuje ve větě, kterou byste přeskočili — „větší nečtvercové rozlišení může někdy vytvořit méně output tokens než menší nebo čtvercové rozlišení při stejném nastavení kvality“ — a u předchozí generace modelů to běželo opačně, portrait stál o 50 % víc než square.¹¹ Každé výchozí 1024x1024 napsané před touto změnou je teď drahá volba.

Požádejte tři produkty, aby přečetly stejných 519 znaků — asi 38 sekund audia — a od dvou vendorů dostanete tři systémy jednotek:

Stejný vendor prodává obě jednotky: OpenAI tts-1 je oceněné za milion znaků, zatímco gpt-4o-mini-tts je oceněné za milion tokenů, $0.60 dovnitř a $12.00 ven.¹³ Takže „nejlevnější text-to-speech“ není otázka s odpovědí, dokud neřeknete, co se má číst.

A obě jednotky jsou slepé k opačným věcem. Cena za znak nevidí délku trvání: zvolte pomalý, rozvážný hlas nebo přidejte pauzy a účet se nepohne, zatímco audio se prodlouží. Cena za sekundu nevidí obsah: třicet sekund stojí stejně, ať je to hutný technický odstavec, nebo někdo počítá do deseti. Změňte hlas a přesně jeden z vašich dvou vendorů přecení.

Přepis běží opačně a je nejjednodušší řádek na celé faktuře — za minutu audia, paušálně:

whisper                  $0.005960     ($0.006 / min)
gpt-transcribe           $0.004470     ($0.0045 / min)
gpt-4o-mini-transcribe   $0.002980     ($0.003 / min)
gpt-live-transcribe      $0.016887     ($0.017 / min)

Všimněte si posledního řádku proti třetímu: dělat to živě, jak slova přicházejí, stojí 5,7krát tolik co dělat to z hotového souboru. Ten rozdíl je cena za nemožnost batch, a právě kvůli němu je další sekce drahá.

Teď číslo, které rozhoduje, zda je hlas funkce, nebo produkt.

Hovor: podpůrná konverzace o deseti tazích, 149 slov, což při deklarovaných 150 slovech za minutu znamená 59,6 sekundy řeči — 21,2 vyřčených volajícím, 38,4 řečených zpět. Převody na tokeny jsou vlastní převody providerů. OpenAI: „audio tokens v user messages jsou 1 token na 100 ms audia, zatímco audio tokens v assistant messages jsou 1 token na 50 ms“.¹⁴ Google: 25 tokenů za sekundu v obou směrech, což jeho cenová stránka potvrzuje publikací $12.00 za milion a $0.018 za minutu na stejném řádku.¹²

Konverzace se akumuluje přesně tak, jak říkala Kapitola 16, protože je to stejný mechanismus: „celá konverzace se posílá modelu pro každý Response... pozdější tahy v session tedy budou dražší“.¹⁴ Jen teď se historie měří v audio tokens.

Teď srovnání, které rozhoduje produkt, všechny čtyři normalizované na minutu:

Třicet osmkrát. Ne třicet osm procent. Identická výměna vedená zvukem místo textu je téměř o dva řády dražší, a žádná část toho rozdílu není marže, kterou se někdo rozhodl účtovat — je to převodní poměr. Jedna sekunda assistant audia je dvacet tokenů. Tatáž sekunda nese při deklarované rychlosti 2,5 slova a měřený přepis běží na 1,26 tokenu na slovo, takže jako text je to 3,15 tokenu. Zvuk je 6,3krát objemnější balík pro stejný význam a každý jeho token se účtuje 5,3krát vyšší sazbou než textový výstup a 16krát vyšší sazbou než textový vstup. Vynásobte objemový poměr cenovým poměrem a řád je jasný ještě před jakýmkoli účetnictvím.

Z tabulky přímo plynou dva provozní důsledky.

Audio caching není optimalizace, je to obchodní model. Cached audio input stojí $0.40 za milion proti $32.00 za fresh — sleva 98,75 %, která hovor zlevní na polovinu. Pravidlo je z Kapitoly 16, beze změny: cache páruje prefix, takže cokoli vložené doprostřed hovoru na začátek konverzace ji zničí, a přirozené místo, kam dát „volající je nyní ověřen“, je přesně tam.

A nic, co uděláte v klientu, zvuk neodúčtuje. Uživatel skočí asistentovi do řeči, váš kód zastaví přehrávání, reproduktor ztichne. Cokoli už bylo vygenerováno, už bylo účtováno, protože billing narůstá při vytvoření response; a podle pravidla Kapitoly 16 se cokoli, co zůstane v konverzaci, znovu posílá jako input audio při každém dalším tahu. Kapitola 14 to říkala o přerušení textového streamu. U hlasu to stojí třicetkrát víc.

Video někteří vendoři prodávají za sekundu a jiní za klip, s úrovněmi pro rozlišení a někdy pro délku. Tyto dva tvary se neliší jen pohodlím; protínají se.

Vendor účtující za klip je dražší než ten sekundový pod 1,2 sekundy a 16,7krát levnější u dvaceti sekund. Žádné pořadí těchto dvou modelů nepřežije změnu délky klipu, takže „který video model je nejlevnější“ není otázka na modely.

Poslední řádek je horší, a je poctivým jádrem kapitoly. mochi se účtuje podle skutečných GPU sekund — naměřeného prediction time jobu — za $0.001400 za sekundu na A100 a $0.001525 na H100, což jsou sazby pronajatého stroje a nic jiného.¹⁵ Je to dokonale přesný tarif a není to cena, protože veličina, kterou násobí, není známa, dokud se nezavážete ji zaplatit. Řádek výše předpokládá dvanáct GPU-sekund na sekundu výstupu; zčtyřnásobte ten předpoklad a opustí nejlevnější pásmo, a teprve při šestinásobku dopadne doprostřed tabulky. Je to jediný tarif na této stránce, který nemůžete dát do nabídky.

Takže: tokens, image tokens, znaky, minuty, video sekundy, celé klipy, GPU sekundy, paušální jednotky. Osm veličin, a jediný způsob, jak je dát na jednu osu, je deklarovat workload a ocenit ho.

To je rozšíření computeCost z Kapitoly 16 — stejný tier mechanismus, teď s kritérii, která nejsou délka prompt:

export interface MediaCriteria {
  resolution?: string[]; quality?: string[];
  hasAudio?: boolean; maxDurationSeconds?: number;
}
export interface MediaTier { when?: MediaCriteria; price: number }
export type MediaRate = number | MediaTier[];

const matches = (when: MediaCriteria, u: Usage) => {
  const inList = (l?: string[], v?: string) => !l || (v !== undefined && l.includes(v));
  if (!inList(when.resolution, u.resolution)) return false;
  if (!inList(when.quality, u.quality)) return false;
  if (when.hasAudio !== undefined && when.hasAudio !== (u.hasAudio ?? false)) return false;
  if (when.maxDurationSeconds !== undefined
      && (u.videoSeconds ?? 0) > when.maxDurationSeconds) return false;   
  return true;
};

const mediaPrice = (rate: MediaRate | undefined, u: Usage): number => {
  if (rate === undefined) return 0;
  if (typeof rate === "number") return rate;
  for (const t of rate.filter((t) => t.when)) if (matches(t.when!, u)) return t.price;
  return rate.find((t) => !t.when)?.price ?? 0;      // the tier with no criteria is the default
};

export function computeCost(p: Pricing, u: Usage): number {
  let c = textCost(p, u);                             // Chapter 16, unchanged
  if (p.imageInputToken || p.imageOutputToken) {
    c += (u.imageInputTokens ?? 0) * (p.imageInputToken ?? 0)
       + (u.imageOutputTokens ?? 0) * (p.imageOutputToken ?? 0);
  } else if (p.imageUnit !== undefined) c += (u.images ?? 1) * mediaPrice(p.imageUnit, u);  
  if (p.videoSecond !== undefined) c += (u.videoSeconds ?? 0) * mediaPrice(p.videoSecond, u);
  if (p.videoUnit   !== undefined) c += (u.videoCount ?? 1)   * mediaPrice(p.videoUnit, u);
  c += (u.audioInputTokens ?? 0)       * (p.audioInputToken ?? 0)
     + (u.cachedAudioInputTokens ?? 0) * (p.cachedAudioInputToken ?? p.audioInputToken ?? 0)
     + (u.audioOutputTokens ?? 0)      * (p.audioOutputToken ?? 0)
     + (u.computeSeconds ?? 0)         * (p.computeSecond ?? 0)
     + (u.chars ?? 0)                  * (p.perChar ?? 0)
     + (u.minutes ?? 0)                * (p.perMinute ?? 0);
  return c;
}

Dva označené řádky ukazují, kde se to láme. Tarif uvedený za jednotku násobí u.images ?? 1; tarif uvedený za token násobí něco, co má výchozí nulu. Nakrmte obojí prázdným usage — tvarem, který dostanete, když měření selhalo — a dívejte se:

per image (nano-banana-pro)     empty usage => $0.1500
per clip  (hailuo-02)           empty usage => $0.1500
per unit  (a cloned voice)      empty usage => $3.0000
per token (gpt-image-2)         empty usage => $0.0000
per second (veo-3.1)            empty usage => $0.0000
per GPU-second (mochi)          empty usage => $0.0000

Nic se nestalo, šestkrát, a jednou to stálo tři dolary a pětkrát nic. To není rozdíl v zaokrouhlení; je to rozhodnutí o tom, co znamená chybějící číslo, učiněné zvlášť pro každou jednotku a nikde nezapsané. Rozumné pravidlo je, že pole, které nikdo neměřil, zůstává absent, protože „neměřeno“ a „změřeno a vyšlo nula“ jsou různé věci. Tato funkce tiše nesouhlasí.

Druhé selhání je délka trvání. Tarif za klip vybírá tier pomocí maxDurationSeconds proti u.videoSeconds ?? 0, takže usage, které nikdy nezaznamenalo duration, odpovídá nejkratší úrovni:

duration recorded    ->  $0.45
duration missing     ->  $0.27

Čtyřicetiprocentní sleva za to, že nevíte, jak dlouhé video bylo. Obě chyby mají stejný kořen: default zvolený pro pohodlí uvnitř funkce, jejímž jediným úkolem je být přesná.

Když jsou náklady spočitatelné, srovnání potřebuje druhou polovinu — deklarovaný reprezentativní workload, jeden pro každý engine, zveřejněný tak, aby s ním čtenář mohl nesouhlasit:

export const representative = {
  text:   { blend: [[{ promptTokens: 1e6 }, 0.25], [{ completionTokens: 1e6 }, 0.75]] },
  image:  { images: 1, imageInputTokens: 50, imageOutputTokens: 1500 },
  video:  { videoSeconds: 5, videoCount: 1, resolution: "1080p", hasAudio: true, computeSeconds: 60 },
  voice:  { chars: 1000, computeSeconds: 10 },
  stt:    { minutes: 1 },
};

Každý z těchto řádků je argument. Text míchá čtvrtinu vstupu a tři čtvrtiny výstupu, protože reálné použití se kloní k výstupu; směs padesát na padesát seřadí modely jinak. Image workload předpokládá 1 500 output tokens, mezi 1 056 OpenAI pro medium square a 1 584 pro medium portrait. Video předpokládá pět sekund při 1080p, a právě jsme viděli dva vendory prohodit si místa při 1,2 sekundy. Compute položka předpokládá šedesát GPU-sekund, protože není co jiného předpokládat.

To je metoda, a je jediná poctivá dostupná: nemůžete porovnávat ceny v různých jednotkách; můžete porovnávat jen náklady workload, který jste zapsali. Jakákoli tabulka řadící multimodální modely bez vytištění workload řadí vlastní předpoklady.

Teď umíte ocenit cokoli, co model dokáže vytvořit, v jakékoli jednotce se to prodává, a nahlas říct, jaký workload vaše srovnání předpokládalo. Tím se uzavírá faktura otevřená Kapitolou 16 a uzavírá se Část III: všechno od Kapitoly 14 až sem bylo o jednom volání — jak ho udělat, co do něj dát, jak ho sample, co vrací, co stojí.

Kapitola 22 mění jednotku analýzy, a ta změna je drahá. Agent není jedno volání; je to smyčka, která sama rozhoduje, kolik volání udělá, a aritmetika posledních dvou kapitol je to, co z architektonického diagramu dělá rozpočet. Začíná tím, že stejnému modelu položí stejnou otázku dvakrát, podruhé s jedním tool přidaným do katalogu, a změří, co ten jeden tool udělal: jedno volání se stalo dvěma, třicet devět input tokens se stalo 420.

Jestli z něj tohle dělá agent, záleží na tom, kterou ze dvou publikovaných definic otevřete, a ty se neshodují. Jedna z nich se neshoduje ani sama se sebou.

Každá cena, vzorec a převodní sazba v této kapitole byly přečteny z vlastní stránky providera dne 7. září 2026 a jsou citovány s tímto datem, protože všechny se budou měnit. Počty tokenů, náklady a srovnání byly spočítány z těchto dat kódem vytištěným výše, na jednom stroji, bez placeného API volání — což je také poctivý důvod, proč v této kapitole není jediné tvrzení o latenci.

Image-token funkce, cenové tabulky, rozpis hlasového hovoru a výsledky empty-usage byly vytvořeny TypeScriptem vytištěným v této kapitole, spuštěným na Node 22. Dialog použitý pro hlasové srovnání má 149 slov a byl tokenizován pomocí tiktoken pod encoding o200k_base na 188 tokenů; jeho duration vychází z deklarované rychlosti 150 slov za minutu, což je parametr srovnání, ne měření. Každý údaj providera nese poznámku pod čarou, která jmenuje stránku, odkud pochází.