Cennik multimodalny: za co naprawdę płacisz przy obrazach, audio i wideo

Transformer przyjmuje sekwencję wektorów. Nie interesuje go, skąd pochodzą. Rozdział 8 podawał mu embeddings pobierane z identyfikatora token; nic w architekturze nie wymaga tego lookupu.

A więc: potnij obraz na stałe kwadraty, spłaszcz każdy kwadrat do listy liczb i przepuść każdą listę przez jedną wyuczoną warstwę liniową, żeby dostać wektor o szerokości modelu. Patch 32 × 32 kolorowych pikseli to $32 \times 32 \times 3 = 3072$ liczb; projekcja $E \in \mathbb{R}^{d \times 3072}$ zamienia go w jeden $d$-wymiarowy wektor, dokładnie o takim kształcie, w jakim przychodzi text token. To cała sztuka, i to mówi już tytuł pracy: obraz jest wart 16 × 16 słów.¹ Dodaj positional encoding, żeby model wiedział, który kwadrat był gdzie, przepleć wyniki z text embeddings, a sekwencja czytana przez model będzie częściowo obrazem i częściowo zdaniem.

Trzy prace zmieniły to w produkt. CLIP wytrenował image encoder i text encoder tak, by uzgadniały — na czterystu milionach zeskrobanych par — co sprawiło, że pomysł wspólnej przestrzeni dla pikseli i słów przestał być hipotezą.² Flamingo przykręciło zamrożony vision encoder do zamrożonego language model za pomocą kilku trenowanych warstw pomostowych.³ LLaVA pokazała, że pomostem może być pojedyncza projekcja liniowa, a instruction-following da się nauczyć na wygenerowanych danych, dlatego każdy otwarty vision-language model od tamtej pory wygląda z grubsza tak samo.⁴

Konsekwencja dla faktury jest natychmiastowa i mało efektowna: patches są pozycjami w sekwencji, więc są input tokens, więc płacisz za nie według stawki input. Ile ich jest, wynika z arytmetyki, a każdy dostawca robi ją inaczej.

Każda reguła poniżej jest zaimplementowana na podstawie własnej dokumentacji dostawcy i sprawdzona na przykładach obliczeniowych z tej samej dokumentacji.

OpenAI pokrywa obraz patchami 32 × 32 i mnoży ich liczbę przez współczynnik zależny od modelu. Jeśli liczba patchy przekracza budżet dla tego modelu i poziomu szczegółowości, obraz jest skalowany w dół, aż się zmieści:

Anthropic pokrywa go patchami 28 × 28, po jednym visual token każdy, i ogranicza zarówno dłuższą krawędź, jak i liczbę token — 1,568 pikseli i 1,568 tokens w modelach standard-tier, 2,576 i 4,784 w high-resolution tier. Zbyt duże obrazy są skalowane do największego rozmiaru, który mieści się w obu limitach.⁵

Google w ogóle nie liczy pikseli. Obraz, którego oba boki mają co najwyżej 384 piksele, kosztuje stałe 258 tokens. Wszystko większe jest cięte na kafelki po 258 tokens każdy, a siatka kafelków wynika z jednostki kadrowania $\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;      
}

Uruchom każdą regułę na liczbach, które drukuje jej własny dostawca:

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

Wydrukowanych jest dziewięć zgodności; pełne uruchomienie sprawdza piętnaście, ponieważ tabela Anthropic podaje oba tiers dla wszystkich sześciu rozmiarów. Reguły są teraz twoje do uruchomienia na dowolnej fotografii, którą masz, i o to chodzi: to jedyne trzy funkcje w tym rozdziale, których nie dostaniesz ze strony z cenami.

Przepuść tę samą fotografię 4:3 przez wszystkie trzy reguły w sześciu rozmiarach:

Czytaj ostatnią kolumnę w dół. Gdy obraz przekroczy 384 piksele, liczba już nigdy się nie zmienia, i nie jest to przypadek ani limit. Podstaw jednostkę kadrowania z powrotem do wzoru na kafelki, dla obrazu co najmniej tak szerokiego jak wysokiego:

Rozmiar się skraca. Google image tokens zależą od proporcji obrazu i od niczego więcej. Fotografia 4:3 ma cztery kafelki, niezależnie od tego, czy jest miniaturą, czy plakatem. Ten jeden fakt algebraiczny jest całym wyjaśnieniem zera w tabeli oszczędności powyżej, a żadna strona z cenami nigdzie go nie podaje.

Pozostałe dwie kolumny zamiast tego dochodzą do limitu, na innych wysokościach i z innych powodów — Anthropic przy zadeklarowanym suficie token, OpenAI przy budżecie patchy po limicie pikseli — dlatego trzy krzywe przecinają się przy różnych rozmiarach.

Teraz to zepsuj. Oczywisty sposób, żeby wydać mniej na vision model, to poprosić o mniej szczegółów, więc wyślij detail: "low":

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

Prośba o mniej szczegółów kosztowała 25 % więcej. To nie bug, a OpenAI mówi o tym w jednym wierszu tabeli rozmiarów: w tej rodzinie modeli low używa limitu 2048 pikseli i budżetu 6,144 patchy, podczas gdy high używa tego samego limitu pikseli z budżetem 2,500 patchy, „so it can use more tokens than high”.⁷ Słowo low nazywa ustawienie wierności, nie ceny: w dwóch z pięciu udokumentowanych rodzin modeli nie daje żadnej oszczędności, a w jednej z tych dwóch kosztuje więcej.

Wszystko do tej pory dotyczyło modelu czytającego obraz. Tworzenie obrazu działa na mechanizmie, w którym nie ma tokens w ogóle, i dlatego sprzedaje się je za obraz, a nie za słowo.

Dostawcy publikują generowanie obrazów jako cenę za obraz. To nie jest jedna cena. Modele GPT Image emitują wyspecjalizowane image tokens, których liczba zależy od żądanego rozmiaru i jakości; pomnóż opublikowane liczby przez opublikowaną stawkę image output GPT Image 1, czyli $40 za milion, i porównaj z cenami za obraz na tej samej stronie:

Dziewięć liczb wyprowadzonych wobec dziewięciu opublikowanych, każda para zgodna w granicach $0.002.¹¹ Google jest jeszcze bardziej dosłowne i wykonuje konwersję za ciebie na samej stronie z cenami: image output po $60 za milion tokens, „output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image”.¹²

Cena za obraz jest więc ceną za token z wliczoną liczbą token. To w porządku, ale coś ukrywa. Weź tabelę bieżącej generacji i podziel wstecz:

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

Większy obraz jest tańszy przy każdej jakości. Canvas 1024 × 1536 ma o 50 % więcej pikseli niż 1024 × 1024 i kosztuje o 23 % mniej tokens przy medium. OpenAI zaznacza to w zdaniu, które byś pominął — „a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting” — a w poprzedniej generacji modeli działało to odwrotnie: portret kosztował 50 % więcej niż kwadrat.¹¹ Każde domyślne 1024x1024 zapisane przed tą zmianą jest teraz drogą opcją.

Poproś trzy produkty, żeby wypowiedziały te same 519 znaków — około 38 sekund audio — a dostaniesz trzy systemy jednostek od dwóch dostawców:

Ten sam dostawca sprzedaje obie jednostki: tts-1 od OpenAI jest wyceniany za milion znaków, a gpt-4o-mini-tts za milion tokens, $0.60 wejścia i $12.00 wyjścia.¹³ Dlatego „najtańszy text-to-speech” nie jest pytaniem z odpowiedzią, dopóki nie powiesz, co ma być wypowiedziane.

A te dwie jednostki są ślepe na przeciwne rzeczy. Cena za znak nie widzi czasu trwania: wybierz powolny, staranny głos albo dodaj pauzy, a rachunek się nie ruszy, choć audio będzie dłuższe. Cena za sekundę nie widzi treści: trzydzieści sekund kosztuje tyle samo, niezależnie od tego, czy to gęsty akapit techniczny, czy ktoś liczący do dziesięciu. Zmień głos, a dokładnie jeden z dwóch dostawców przeliczy cenę.

Transkrypcja działa odwrotnie i jest najprostszą pozycją na całej fakturze — płasko za minutę audio:

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)

Zwróć uwagę na ostatni wiersz wobec trzeciego: zrobienie tego na żywo, w miarę napływania słów, kosztuje 5,7 raza więcej niż praca na gotowym pliku. Ta różnica jest ceną za brak możliwości batch, i to ona sprawia, że następna sekcja jest droga.

Teraz liczba, która decyduje, czy głos jest funkcją, czy produktem.

Rozmowa: dziesięcioturowa konwersacja support, 149 słów, co przy zadeklarowanych 150 słowach na minutę daje 59,6 sekundy mowy — 21,2 wypowiedziane przez dzwoniącego, 38,4 wypowiedziane w odpowiedzi. Konwersje token są własne dla dostawców. OpenAI: „audio tokens in user messages are 1 token per 100 ms of audio, while audio tokens in assistant messages are 1 token per 50 ms”.¹⁴ Google: 25 tokens na sekundę, w obie strony, co jego strona z cenami potwierdza, publikując $12.00 za milion i $0.018 za minutę w tym samym wierszu.¹²

Konwersacja narasta dokładnie tak, jak mówił Rozdział 16, bo to ten sam mechanizm: „the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive”.¹⁴ Tyle że teraz historia jest mierzona w audio tokens.

Teraz porównanie, które decyduje o produkcie, wszystkie cztery znormalizowane do minuty:

Trzydzieści osiem razy. Nie trzydzieści osiem procent. Ta sama wymiana, przeprowadzona dźwiękiem zamiast tekstem, jest prawie o dwa rzędy wielkości droższa, i żadna część tej różnicy nie jest marżą, którą ktoś postanowił naliczyć — to kurs konwersji. Jedna sekunda audio assistant to dwadzieścia tokens. Ta sama sekunda niesie 2,5 słowa przy zadeklarowanej szybkości, a zmierzony transkrypt ma 1,26 tokens na słowo, więc jako tekst to 3,15 tokens. Dźwięk jest 6,3 raza bardziej masywnym opakowaniem dla tego samego znaczenia, a każdy jego token jest rozliczany po 5,3 raza wyższej stawce niż text output i 16 razy wyższej niż text input. Pomnóż współczynnik objętości przez współczynnik ceny, a rząd wielkości jest widoczny jeszcze przed rozpoczęciem księgowości.

Z tabeli wynikają wprost dwie konsekwencje operacyjne.

Audio caching nie jest optymalizacją, tylko modelem biznesowym. Cached audio input kosztuje $0.40 za milion wobec $32.00 świeżego — rabat 98,75 %, który obniża koszt rozmowy o połowę. Reguła jest ta sama co w Rozdziale 16: cache dopasowuje prefix, więc cokolwiek wstawione na początku konwersacji w trakcie rozmowy niszczy go, a naturalne miejsce na „caller is now verified” jest dokładnie tam.

I nic, co zrobisz w kliencie, nie cofnie naliczenia za dźwięk. Użytkownik mówi na głos assistant, twój kod zatrzymuje odtwarzanie, głośnik milknie. Wszystko, co zostało już wygenerowane, zostało już naliczone, bo rozliczenie narasta, gdy Response jest tworzony; a według reguły z Rozdziału 16 wszystko, co zostaje w konwersacji, jest ponownie wysyłane jako input audio w każdej kolejnej turze. Rozdział 14 mówił to o przerywaniu text stream. W głosie kosztuje to trzydzieści razy więcej.

Wideo bywa sprzedawane za sekundę przez jednych dostawców i za klip przez innych, z tier dla rozdzielczości, a czasem też czasu trwania. Te dwa kształty nie różnią się tylko wygodą; one się przecinają.

Dostawca rozliczany za klip jest droższy niż rozliczany za sekundę poniżej 1,2 sekundy i 16,7 raza tańszy przy dwudziestu. Żadne uporządkowanie tych dwóch modeli nie przetrwa zmiany długości klipu, więc „który video model jest najtańszy” nie jest pytaniem o modele.

Ostatni wiersz jest gorszy, i jest uczciwym sercem rozdziału. mochi jest rozliczany według rzeczywistych GPU seconds — zmierzonego czasu predykcji zadania — po $0.001400 za sekundę na A100 i $0.001525 na H100, czyli wyłącznie według stawek wynajętej maszyny.¹⁵ To idealnie precyzyjna taryfa i nie jest ceną, bo wielkość, którą mnoży, jest nieznana aż do chwili, gdy zobowiążesz się za nią zapłacić. Wiersz powyżej zakłada dwanaście GPU-sekund na sekundę output; poczwórz to założenie, a wypada z najtańszego pasma, i dopiero przy sześciokrotności ląduje w środku tabeli. To jedyna taryfa na tej stronie, której nie da się wstawić do oferty.

A więc: tokens, image tokens, znaki, minuty, sekundy wideo, całe klipy, GPU seconds, jednostki stałe. Osiem wielkości, a jedyny sposób, by położyć je na jednej osi, to zadeklarować workload i go wycenić.

To rozszerzenie computeCost z Rozdziału 16 — ta sama maszyneria tier, teraz z kryteriami, które nie są długością 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;
}

Dwie oznaczone linie pokazują, gdzie się psuje. Taryfa podana za jednostkę mnoży u.images ?? 1; taryfa podana za token mnoży coś, co domyślnie wynosi zero. Podaj obu pusty usage — kształt, który dostajesz, gdy pomiar się nie udał — i patrz:

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 się nie wydarzyło, sześć razy, a raz kosztowało trzy dolary i pięć razy nic. To nie różnica zaokrągleń; to decyzja o tym, co znaczy brak liczby, podjęta osobno dla każdej jednostki i nigdy niezapisana. Rozsądna reguła mówi, że pole, którego nikt nie zmierzył, pozostaje nieobecne, bo „nie zmierzono” i „zmierzono i wyszło zero” to różne rzeczy. Ta funkcja po cichu się z tym nie zgadza.

Druga awaria to czas trwania. Taryfa za klip wybiera swój tier przez maxDurationSeconds wobec u.videoSeconds ?? 0, więc usage, który nigdy nie zapisał czasu trwania, trafia do najkrótszego tier:

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

Czterdzieści procent rabatu za niewiedzę, jak długi był film. Oba bugi mają ten sam korzeń: domyślna wartość wybrana dla wygody wewnątrz funkcji, której całym zadaniem jest bycie dokładną.

Gdy koszty da się obliczyć, porównanie potrzebuje drugiej połowy — zadeklarowanego reprezentatywnego workload, po jednym na engine, publicznie opisanego, żeby czytelnik mógł się z nim nie zgodzić:

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żdy z tych wierszy jest argumentem. Tekst miesza ćwierć input i trzy czwarte output, bo realne użycie przechyla się ku output; mieszanka pół na pół ustawi modele inaczej. Workload dla obrazu zakłada 1,500 output tokens, między 1,056 OpenAI dla średniego kwadratu a 1,584 dla średniego portretu. Wideo zakłada pięć sekund w 1080p, a przed chwilą widzieliśmy, jak dwóch dostawców zamienia się miejscami przy 1,2 sekundy. Wpis compute zakłada sześćdziesiąt GPU-sekund, bo nie ma czego innego założyć.

Taka jest metoda, i to jedyna uczciwa dostępna metoda: nie możesz porównywać cen w różnych jednostkach; możesz porównywać tylko koszt workload, który zapisałeś. Każda tabela, która szereguje modele multimodalne bez wydrukowania swojego workload, szereguje własne założenia.

Możesz teraz wycenić wszystko, co model potrafi wyprodukować, w dowolnej jednostce, w której jest sprzedawane, i powiedzieć na głos, jaki workload założyło twoje porównanie. To zamyka fakturę otwartą w Rozdziale 16 i zamyka Część III: wszystko od Rozdziału 14 do tego miejsca dotyczyło jednego call — jak go wykonać, co do niego włożyć, jak go samplować, co zwraca, ile kosztuje.

Rozdział 22 zmienia jednostkę analizy, a ta zmiana jest droga. Agent to nie jeden call; to pętla, która sama decyduje, ile calls wykonać, a arytmetyka z ostatnich dwóch rozdziałów zmienia ją z diagramu architektury w budżet. Zaczyna od zadania temu samemu modelowi tego samego pytania dwa razy, z jednym tool dodanym do katalogu za drugim razem, i zmierzenia, co zrobiło to jedno tool: jeden call stał się dwoma, trzydzieści dziewięć input tokens stało się 420.

Czy to czyni z niego agent, zależy od tego, którą z dwóch opublikowanych definicji otworzysz, a one się nie zgadzają. Jedna z nich nie zgadza się sama ze sobą.

Każda cena, wzór i kurs konwersji w tym rozdziale zostały odczytane z własnej strony dostawcy 7 września 2026 i są cytowane z tą datą, bo wszystkie się zmienią. Liczby token, koszty i porównania obliczono na tych danych kodem wydrukowanym wyżej, na jednej maszynie, bez żadnego płatnego API call — co jest też uczciwym powodem, dla którego w tym rozdziale nie ma ani jednej tezy o latency.

Funkcje image-token, tabele kosztów, rozbicie rozmowy głosowej i wyniki empty-usage zostały wyprodukowane przez TypeScript wydrukowany w tym rozdziale, uruchomiony na Node 22. Dialog użyty do porównania głosu ma 149 słów i został tokenized z tiktoken pod encoding o200k_base do 188 tokens; jego czas trwania wynika z zadeklarowanej szybkości 150 słów na minutę, która jest parametrem porównania, a nie pomiarem. Każda liczba od dostawcy ma przypis wskazujący stronę, z której pochodzi.