Exploring KV Cache Quantization in Multimodal Large Language Model Inference

Who Should Read

Engineers optimizing multimodal LLM inference for production deployments who need to reduce latency and memory footprint without significant quality loss.

Core Mechanics

• The KV (Key-Value) Cache for multimodal inputs is significantly larger than for text-only inputs because image tokens dominate
• Standard KV Cache quantization (INT8/INT4) degrades multimodal quality more than text-only quality — image features are more sensitive to quantization noise
• The paper proposes modality-aware KV quantization: higher precision for image token KV entries, lower precision for text token KV entries
• This mixed-precision approach achieves 1.7x improvement in time-to-first-token and 4.3x improvement in generation throughput
• Quality degradation is minimal: < 1% on VQA benchmarks, < 2% on image captioning tasks
• The memory savings from KV cache quantization allow processing 3x longer multimodal contexts within the same memory budget

Evidence

• Time-to-first-token: baseline 2.4s → quantized 1.4s (1.7x speedup)
• Output throughput: baseline 42 tokens/s → quantized 181 tokens/s (4.3x speedup)
• VQA accuracy drop: INT8 modality-aware quantization shows 0.8% accuracy loss vs. 3.2% for uniform INT8 quantization

How to Apply

• For vLLM or TensorRT-LLM deployments: implement modality-aware KV cache quantization by identifying which KV cache entries correspond to image tokens and applying INT8 to text entries, INT4 or FP8 to image entries — or vice versa based on your quality requirements.
• The quantization benefit is largest when image token counts are high — if you're processing many images or high-resolution inputs, prioritize this optimization.
• Profile your specific model and hardware combination: the optimal precision split varies — start with INT8/INT4 text/image and benchmark quality vs. throughput tradeoffs.

Code Example

# Conceptual application example (PyTorch pseudo-code)
import torch

def mixed_precision_kv_cache(keys, values, text_token_mask, quant_bits=4):
    """
    text_token_mask: True positions are text tokens (top 10%)
    Image tokens are quantized to lower bits
    """
    # Text tokens: maintain high precision
    keys_text = keys[text_token_mask]      # Keep as FP16
    values_text = values[text_token_mask]

    # Image tokens: INT4 quantization
    keys_img = keys[~text_token_mask]
    values_img = values[~text_token_mask]

    scale_k = keys_img.abs().max() / (2 ** (quant_bits - 1) - 1)
    keys_img_q = (keys_img / scale_k).round().to(torch.int8)

    scale_v = values_img.abs().max() / (2 ** (quant_bits - 1) - 1)
    values_img_q = (values_img / scale_v).round().to(torch.int8)

    return {
        "keys_text": keys_text,
        "values_text": values_text,
        "keys_img_quantized": keys_img_q,
        "keys_img_scale": scale_k,
        "values_img_quantized": values_img_q,
        "values_img_scale": scale_v,
    }

Terminology

Related Papers

• Claude Code sends 33k tokens before reading the prompt; OpenCode sends 7k

  동일한 모델과 작업 환경에서 Claude Code와 OpenCode의 실제 토큰 사용량을 API 레벨에서 측정한 결과, Claude Code가 시스템 프롬프트 오버헤드만으로 OpenCode 대비 4.7배 더 많은 토큰을 소비한다는 것을 확인했다.

• Mesh LLM: distributed AI computing on iroh

  사무실, 집, 클라우드에 흩어진 GPU들을 하나의 OpenAI 호환 API로 묶어주는 분산 LLM 실행 시스템으로, 비싼 API 비용 없이 큰 모델을 직접 운영할 수 있다.

• Show HN: Frugon – Find which LLM calls a cheaper model could handle (local, MIT)

  내 LLM API 비용이 어디서 새는지 로컬에서 분석해주는 오픈소스 CLI 도구로, 비싼 모델 대신 저렴한 모델로 전환 가능한 호출을 골라낸다.

• Jamesob's guide to running SOTA LLMs locally

  2천 달러짜리 RTX 3090 한 장부터 4만 달러짜리 RTX PRO 6000 4장 셋업까지, 로컬에서 최신 LLM을 직접 돌리는 방법을 하드웨어 선택·구성·실행 설정까지 통째로 정리한 실전 가이드다.

• Faster embeddings: how we rebuilt the ONNX path in Manticore

  Manticore Search가 기존 SentenceTransformers/Candle 백엔드를 ONNX Runtime으로 교체해 텍스트 임베딩 생성 속도를 평균 14배 향상시켰다. 별도 모델 서비스 없이 DB 내부에서 직접 임베딩을 처리하는 구조에서 INSERT 속도가 곧 임베딩 속도이기 때문에 이 개선은 실질적인 ingest 처리량 향상으로 직결된다.

• Asymmetric Quantization: Near-Lossless Retrieval with 97% Storage Reduction

  멀티벡터 검색 모델의 문서 벡터를 1비트 이진값으로 압축하고 쿼리 벡터만 int8로 유지하는 비대칭 양자화 기법으로, 스토리지를 97% 줄이면서 검색 품질 손실을 0.61점(NDCG@10 기준)에 그치게 만든 실제 프로덕션 적용 사례다.