Định giá multimodal: hình ảnh, âm thanh và video thực sự tính phí gì

Một transformer nhận một chuỗi vector. Nó không quan tâm chúng đến từ đâu. Chương 8 đã đưa vào nó các embedding tra từ token id; không có gì trong kiến trúc bắt buộc phải có bước tra cứu đó.

Vậy nên: cắt ảnh thành các ô vuông cố định, làm phẳng mỗi ô thành một danh sách số, rồi đẩy từng danh sách qua một lớp tuyến tính đã học để nhận một vector có chiều rộng của model. Một patch pixel màu 32 × 32 là $32 \times 32 \times 3 = 3072$ số; phép chiếu $E \in \mathbb{R}^{d \times 3072}$ biến nó thành một vector $d$ chiều, đúng hình dạng mà một text token đi vào. Toàn bộ chỉ có vậy, và bài báo đã nói ngay trong tiêu đề: một hình ảnh đáng giá 16 × 16 từ.¹ Thêm positional encoding để model biết ô nào ở đâu, xen kẽ kết quả với text embeddings, và chuỗi model đọc là một phần ảnh, một phần câu.

Ba bài báo đã biến nó thành sản phẩm. CLIP huấn luyện một image encoder và một text encoder để đồng thuận, trên bốn trăm triệu cặp thu thập được, và đó là nơi ý tưởng pixel và từ có thể chia sẻ một không gian thôi còn là giả thuyết.² Flamingo gắn một vision encoder đóng băng vào một language model đóng băng bằng vài lớp cầu nối được huấn luyện.³ LLaVA cho thấy cầu nối có thể chỉ là một phép chiếu tuyến tính và khả năng làm theo chỉ dẫn có thể được dạy bằng dữ liệu sinh ra, đó là lý do mọi open vision-language model kể từ đó trông đại khái giống nhau.⁴

Hệ quả trên hóa đơn của bạn là tức thì và chẳng hào nhoáng: các patch là vị trí trong chuỗi, nên chúng là input tokens, nên bạn trả tiền cho chúng theo mức input. Bao nhiêu là phép số học, và mỗi provider làm khác nhau.

Mỗi quy tắc bên dưới được triển khai từ chính tài liệu của provider và được kiểm lại bằng các ví dụ đã tính trong cùng tài liệu đó.

OpenAI phủ ảnh bằng các patch 32 × 32 và nhân số lượng với một hệ số theo model. Nếu số patch vượt ngân sách cho model và mức detail đó, ảnh được scale down cho đến khi vừa:

Anthropic phủ ảnh bằng các patch 28 × 28, mỗi patch là một visual token, và đặt trần cả cạnh dài lẫn số token — 1.568 pixel và 1.568 token trên các model tier tiêu chuẩn, 2.576 và 4.784 trên tier độ phân giải cao. Ảnh quá lớn được scale xuống kích thước lớn nhất thỏa cả hai.⁵

Google không đếm pixel chút nào. Một ảnh có cả hai cạnh từ 384 pixel trở xuống tốn cố định 258 token. Bất cứ ảnh nào lớn hơn được cắt thành các tile 258 token mỗi tile, và lưới tile đến từ một crop unit là $\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;      
}

Chạy từng quy tắc với những con số chính vendor của nó in ra:

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

Chín kết quả khớp được in ra; lượt chạy đầy đủ kiểm tra mười lăm, vì bảng của Anthropic đưa cả hai tier cho cả sáu kích thước. Giờ các quy tắc đã là của bạn để chạy trên bất kỳ ảnh nào bạn có, đó chính là điểm mấu chốt: đây là ba function duy nhất trong chương này bạn không thể lấy từ một trang giá.

Đưa cùng một ảnh 4:3 qua cả ba ở sáu kích thước:

Đọc cột cuối từ trên xuống. Khi ảnh vượt 384 pixel, con số không bao giờ đổi nữa, và đó không phải trùng hợp hay trần. Thay crop unit ngược vào công thức tile, với một ảnh ít nhất rộng bằng cao:

Kích thước triệt tiêu. image tokens của Google phụ thuộc vào aspect ratio và không gì khác. Một ảnh 4:3 là bốn tile dù nó là thumbnail hay poster. Sự thật đại số duy nhất đó là toàn bộ lời giải thích cho số không trong bảng tiết kiệm ở trên, và không trang giá nào nói điều đó.

Hai cột còn lại thì đặt trần, ở các độ cao khác nhau và vì các lý do khác nhau — Anthropic ở trần token được tuyên bố, OpenAI ở ngân sách patch sau giới hạn pixel — nên ba đường cong cắt nhau ở những kích thước khác nhau.

Giờ hãy làm nó vỡ. Cách hiển nhiên để chi ít hơn cho một vision model là yêu cầu ít detail hơn, nên gửi detail: "low":

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

Yêu cầu ít detail hơn lại tốn nhiều hơn 25 %. Đây không phải bug và OpenAI nói vậy trong một dòng của bảng sizing: trên họ model đó, low dùng giới hạn 2048 pixel với ngân sách 6.144 patch còn high dùng cùng giới hạn pixel với ngân sách 2.500 patch, “nên nó có thể dùng nhiều token hơn high”.⁷ Từ low đặt tên cho một thiết lập fidelity, không phải một mức giá: trên hai trong năm họ model được ghi tài liệu, nó không mua được khoản tiết kiệm nào, và trên một trong hai họ đó nó còn tốn hơn.

Mọi thứ đến giờ là một model đọc ảnh. Tạo một ảnh chạy trên một cơ chế không có token nào trong đó, và đó là lý do nó được bán theo bức thay vì theo từ.

Vendors công bố image generation dưới dạng giá mỗi bức. Thực ra không phải. GPT Image models phát ra các image tokens chuyên biệt mà số lượng phụ thuộc vào kích thước và quality được yêu cầu; nhân số lượng đã công bố với mức image output đã công bố của GPT Image 1 là $40 mỗi triệu rồi so với giá theo ảnh trên cùng trang:

Chín con số suy ra đối chiếu với chín con số công bố, mọi cặp khớp trong phạm vi $0.002.¹¹ Google còn rõ hơn và tự làm phép chuyển đổi cho bạn ngay trên trang giá: image output ở $60 mỗi triệu token, “output images ở 1K (1024x1024px) tiêu thụ 1120 token và tương đương $0.067 mỗi ảnh”.¹²

Vậy giá theo ảnh là giá theo token với số lượng đã được gấp vào. Điều đó ổn, và nó che giấu một thứ. Lấy bảng của thế hệ hiện tại và chia ngược:

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

Ảnh lớn hơn lại là ảnh rẻ hơn ở mọi quality. Một canvas 1024 × 1536 có nhiều pixel hơn 50 % so với 1024 × 1024 và tốn ít token hơn 23 % ở medium. OpenAI đánh dấu điều này trong một câu bạn rất dễ bỏ qua — “một độ phân giải không vuông lớn hơn đôi khi có thể tạo ít output tokens hơn một độ phân giải nhỏ hơn hoặc vuông ở cùng quality setting” — và trên thế hệ model trước, chiều ngược lại xảy ra, portrait tốn nhiều hơn square 50 %.¹¹ Mọi mặc định 1024x1024 được viết trước thay đổi đó giờ là lựa chọn đắt tiền.

Yêu cầu ba sản phẩm đọc cùng 519 ký tự — khoảng 38 giây âm thanh — và bạn nhận ba hệ đơn vị từ hai vendors:

Cùng một vendor bán cả hai đơn vị: tts-1 của OpenAI được định giá theo triệu ký tự trong khi gpt-4o-mini-tts được định giá theo triệu token, $0.60 vào và $12.00 ra.¹³ Vậy “text-to-speech rẻ nhất” không phải câu hỏi có câu trả lời cho đến khi bạn nói rõ mình đang cho nó đọc gì.

Và hai đơn vị mù với hai thứ đối lập. Giá theo ký tự không thấy duration: chọn một giọng chậm, chậm rãi, hoặc thêm khoảng nghỉ, hóa đơn không đổi trong khi âm thanh dài hơn. Giá theo giây không thấy content: ba mươi giây tốn như nhau dù đó là một đoạn kỹ thuật dày đặc hay ai đó đếm đến mười. Đổi giọng và chính xác một trong hai vendor của bạn định giá lại.

Transcription chạy theo hướng ngược lại và là dòng đơn giản nhất trên toàn bộ hóa đơn — theo phút âm thanh, phẳng:

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)

Lưu ý hàng cuối so với hàng thứ ba: làm việc đó live, khi lời nói đang tới, tốn gấp 5,7 lần làm trên một file đã hoàn tất. Khoảng cách đó là giá của việc không thể batch, và nó là thứ làm phần tiếp theo đắt.

Giờ là con số quyết định voice là một tính năng hay một sản phẩm.

Cuộc gọi: một cuộc hội thoại hỗ trợ mười lượt, 149 từ, ở mức được tuyên bố 150 từ mỗi phút là 59,6 giây lời nói — 21,2 giây do người gọi nói, 38,4 giây nói lại. Các chuyển đổi token là của chính providers. OpenAI: “audio tokens trong user messages là 1 token mỗi 100 ms âm thanh, trong khi audio tokens trong assistant messages là 1 token mỗi 50 ms”.¹⁴ Google: 25 token mỗi giây, theo cả hai chiều, điều mà trang giá của họ xác nhận bằng cách công bố $12.00 mỗi triệu và $0.018 mỗi phút trên cùng một dòng.¹²

Cuộc hội thoại tích lũy đúng như Chương 16 đã nói, vì đó là cùng một cơ chế: “toàn bộ cuộc hội thoại được gửi tới model cho mỗi Response... vì vậy các lượt về sau trong session sẽ đắt hơn”.¹⁴ Chỉ khác là giờ lịch sử được đo bằng audio tokens.

Giờ là phép so sánh quyết định sản phẩm, cả bốn đều chuẩn hóa theo một phút:

Ba mươi tám lần. Không phải ba mươi tám phần trăm. Cùng một trao đổi, tiến hành bằng âm thanh thay vì văn bản, đắt hơn gần hai bậc độ lớn, và không phần nào của khoảng cách đó là margin ai đó chọn thu — nó là tỷ lệ chuyển đổi. Một giây assistant audio là hai mươi token. Cũng một giây đó mang 2,5 từ ở tốc độ đã tuyên bố, và transcript đo được chạy ở 1,26 token mỗi từ, nên dưới dạng văn bản nó là 3,15 token. Âm thanh là một gói cồng kềnh hơn 6,3 lần cho cùng ý nghĩa, và mỗi token của nó được tính phí gấp 5,3 lần mức text output và 16 lần mức text input. Nhân tỷ lệ cồng kềnh với tỷ lệ giá, và bậc độ lớn đã có sẵn trước khi kế toán bắt đầu.

Hai hệ quả vận hành rơi thẳng ra từ bảng.

Audio caching không phải tối ưu hóa, nó là business model. Cached audio input là $0.40 mỗi triệu so với $32.00 fresh — chiết khấu 98,75 % làm giảm một nửa cuộc gọi. Quy tắc vẫn là của Chương 16, không đổi: cache khớp một prefix, nên bất cứ thứ gì chèn vào đầu cuộc hội thoại giữa cuộc gọi sẽ phá nó, và nơi tự nhiên để đặt “người gọi giờ đã được xác minh” lại chính xác là chỗ đó.

Và không có gì bạn làm ở client có thể bỏ tính phí một âm thanh. Người dùng nói đè lên assistant, code của bạn dừng playback, loa im. Bất cứ thứ gì đã được sinh ra thì đã bị tính phí, vì billing tích lũy khi response được tạo; và theo quy tắc của Chương 16, bất cứ thứ gì còn trong cuộc hội thoại sẽ được gửi lại, dưới dạng input audio, ở mọi lượt sau đó. Chương 14 đã nêu điểm này về việc abort một text stream. Với voice, nó đắt hơn ba mươi lần.

Video được bán theo giây bởi một số vendors và theo clip bởi số khác, với các tier cho độ phân giải và đôi khi cho duration. Hai hình dạng đó không chỉ khác nhau về tiện lợi; chúng cắt nhau.

Vendor tính theo clip đắt hơn vendor tính theo giây dưới 1,2 giây và rẻ hơn 16,7 lần ở hai mươi giây. Không thứ tự nào giữa hai model đó sống sót sau một thay đổi về độ dài clip, nên “video model nào rẻ nhất” không phải câu hỏi về model.

Hàng cuối còn tệ hơn, và đó là lõi trung thực của chương này. mochi được tính phí theo giây GPU thực — thời gian dự đoán đo được của job — ở $0.001400 mỗi giây trên A100 và $0.001525 trên H100, chỉ là giá thuê máy và không gì khác.¹⁵ Đó là một biểu phí hoàn toàn chính xác và không phải giá, vì đại lượng nó nhân với là ẩn số cho đến sau khi bạn đã cam kết trả tiền. Hàng ở trên giả định mười hai GPU-second cho mỗi giây output; tăng giả định đó gấp bốn lần và nó rời khỏi dải rẻ nhất, và chỉ ở mức gấp sáu lần nó mới hạ cánh giữa bảng. Đây là biểu phí duy nhất trên trang này bạn không thể đưa vào một báo giá.

Vậy: tokens, image tokens, ký tự, phút, giây video, nguyên clip, GPU seconds, đơn vị phẳng. Tám đại lượng, và cách duy nhất để đặt chúng lên một trục là khai báo một workload và định giá nó.

Đó là phần mở rộng cho computeCost của Chương 16 — cùng bộ máy tier, giờ với các criteria không phải độ dài 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;
}

Hai dòng được đánh dấu là nơi nó vỡ. Một biểu phí được báo theo đơn vị nhân với u.images ?? 1; một biểu phí được báo theo token nhân với thứ mặc định là zero. Đưa cho cả hai một usage rỗng — hình dạng bạn nhận được khi phép đo thất bại — và xem:

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

Không có gì xảy ra, sáu lần, và nó tốn ba dollar một lần và không tốn gì năm lần. Đó không phải khác biệt làm tròn; đó là một quyết định về ý nghĩa của một con số vắng mặt, một quyết định được đưa ra riêng cho từng đơn vị và không bao giờ được ghi lại. Quy tắc đúng đắn là một field không ai đo thì vẫn vắng mặt, vì “không được đo” và “đã đo và ra zero” là hai việc khác nhau. Hàm này âm thầm bất đồng.

Lỗi thứ hai là duration. Biểu phí theo clip chọn tier của nó bằng maxDurationSeconds so với u.videoSeconds ?? 0, nên một usage chưa từng ghi duration khớp với tier ngắn nhất:

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

Giảm bốn mươi phần trăm vì không biết video dài bao lâu. Cả hai bug có cùng gốc: một mặc định được chọn cho tiện bên trong một function mà toàn bộ nhiệm vụ là phải chính xác.

Khi chi phí đã tính được, phép so sánh cần nửa còn lại — một workload đại diện được khai báo, mỗi engine một workload, công bố công khai để người đọc có thể không đồng ý:

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 },
};

Mỗi dòng trong đó là một luận điểm. Text trộn một phần tư input và ba phần tư output vì mức dùng thực tế lệch về output; một blend năm mươi-năm mươi sẽ xếp hạng model khác đi. Workload image giả định 1.500 output tokens, nằm giữa 1.056 của OpenAI cho square medium và 1.584 cho portrait medium. Video giả định năm giây ở 1080p, và ta vừa thấy hai vendor đổi chỗ ở 1,2 giây. Mục compute giả định sáu mươi GPU-second vì chẳng còn gì khác để giả định.

Đó là phương pháp, và là phương pháp trung thực duy nhất có được: bạn không thể so sánh giá ở các đơn vị khác nhau; bạn chỉ có thể so sánh chi phí của một workload mà bạn đã viết ra. Bất kỳ bảng nào xếp hạng multimodal models mà không in workload của nó thì đang xếp hạng chính các giả định của nó.

Giờ bạn có thể định giá bất cứ thứ gì một model có thể tạo ra, bằng bất cứ đơn vị nào nó được bán, và nói rõ workload mà phép so sánh của bạn đã giả định. Điều đó khép lại hóa đơn mà Chương 16 đã mở, và khép lại Phần III: mọi thứ từ Chương 14 đến đây đều nói về một call — cách tạo nó, đưa gì vào nó, sample nó thế nào, nó trả về gì, nó tốn bao nhiêu.

Chương 22 đổi đơn vị phân tích, và thay đổi đó đắt. Một agent không phải một call; nó là một vòng lặp tự quyết định sẽ thực hiện bao nhiêu call, và số học của hai chương vừa rồi là thứ biến nó từ một sơ đồ kiến trúc thành một ngân sách. Nó mở đầu bằng cách hỏi cùng model cùng một câu hai lần, lần thứ hai thêm một tool vào catalogue, rồi đo xem một tool đó đã làm gì: một call thành hai, ba mươi chín input tokens thành 420.

Điều đó có biến nó thành agent hay không phụ thuộc vào việc bạn mở định nghĩa đã công bố nào trong hai định nghĩa, và chúng không thống nhất. Một trong hai còn không thống nhất với chính nó.

Mọi mức giá, công thức và tỷ lệ chuyển đổi trong chương này được đọc từ trang của chính provider vào 7 September 2026 và được trích cùng ngày đó, vì tất cả chúng sẽ thay đổi. Số lượng token, chi phí và phép so sánh được tính trên dữ liệu đó bằng code in ở trên, trên một máy, không thực hiện API call trả phí nào — đó cũng là lý do trung thực vì sao chương này không có một khẳng định latency nào.

Các function image-token, bảng chi phí, phân tích voice-call và kết quả empty-usage được tạo bởi TypeScript in trong chương này, chạy trên Node 22. Đoạn hội thoại dùng cho so sánh voice có 149 từ và được tokenized bằng tiktoken dưới encoding o200k_base ở 188 token; duration của nó đến từ tốc độ đã khai báo 150 từ mỗi phút, là một tham số của phép so sánh chứ không phải phép đo. Mọi con số của provider đều mang footnote nêu trang nguồn của nó.