🏆 EVIE-Preview-4.5B

Rank #1 on ViDoRe V3 · Rank #1 on ViDoRe V1+V2

The most accurate visual document retriever, with native 128-dimensional token vectors.

🚀 Official Next-Gen Release: EVIE-4.5B (Prefix-MRL & HAC)  •  EVIE-8B (Flagship Teacher)  •  GitHub: Tencent/EVIE

🏆 Results • 💾 Index Cost • ⚡ Quick Start • 🔬 Reproducing • 🧠 Architecture • 📚 Citation

---

📢 Official EVIE Release Notice

You are currently viewing the legacy preview checkpoint EVIE-Preview-4.5B.

For our latest, most accurate, and lightweight visual document retrievers, please switch to the new official models:

• 🌟 tencent/EVIE-4.5B: Official release with single-projection Prefix-MRL (64D–2048D), ARD distillation, and HAC token compression down to 3.81 GiB / 1M pages. ViDoRe V3 66.02.
• 🏛️ tencent/EVIE-8B: Official flagship teacher model with 4096D representations, ViDoRe V3 66.75 (Rank #1).
• 🐙 GitHub: Tencent/EVIE: Open-source repository containing training pipelines, token compression, and reproduction code.

---

🥇 ViDoRe V3 — Rank #1

8 public domains × 6 query languages, nDCG@10.

Two deployment tiers, one checkpoint

EVIE was trained at 768 visual tokens per page. The 1,792 tier is pure test-time extrapolation — the same weights, never trained or fine-tuned at that budget, and never re-exported. That the model does not merely hold up but gains 0.80 nDCG@10 at more than twice its training budget, improving in 7 of the 8 domains, is a direct read on how well its page representation generalises beyond the resolution it was fit to.

Pick whichever tier fits your compute budget.

The lighter tier holds a million pages in under 180 GiB.

Per-domain breakdown

EVIE rows measured with reproduce.sh. Comparison rows are the vendors' published ViDoRe V3 public scores.

---

🥇 ViDoRe V1 + V2 — Rank #1

14 tasks, nDCG@5. First place on the classic boards too.

Tasks 1–10: ViDoRe V1. Tasks 11–14: ViDoRe V2. Board aggregates: V1 91.73 · V2 70.87.

---

💾 Index Cost

Index size is what decides whether multi-vector retrieval actually ships. EVIE emits native 128D token vectors, so the index stays compact at both page budgets.

1,763.58 vectors/page × 128 dim × 2 bytes × 1,000,000 pages ÷ 2^30 = 420.5 GiB

Scoring stays cheap for the same reason: MaxSim is a late-interaction dot product over the token vectors, so a narrower vector cuts the scoring work exactly as it cuts storage.

---

🧠 Architecture

  Text Query ───────► ColQwen3_5 (BiDir Attn) ─────► Query Token Embeddings (128D)
                                                                 │
                                                       Late Interaction (MaxSim) ──► Relevance Score
                                                                 │
Document Image ─────► ColQwen3_5 (Dynamic Vision) ──► Doc Token Embeddings (128D)

1. Vision-Language Backbone — Qwen3.5-4B with interleaved GatedDeltaNet linear attention and full attention.
2. Compact Projection — contextual token states projected directly into native 128-dimensional representations.
3. Late-Interaction Retrieval — token-level MaxSim between query tokens and document visual tokens.

🌍 Multilingual

Queries in English, French, German, Italian, Spanish, Portuguese and Chinese, retrieving over charts, tables, scientific reports, financial filings and scanned forms — including Japanese-language pages.

📦 Model Footprint

---

⚡ Quick Start

ColPali Engine is the reference path — every number on this card comes from it. A Sentence Transformers path is also available for late-interaction pipelines already built on that API.

Installation

pip install "colpali-engine>=0.3.15" accelerate

Or pip install -r requirements.txt if you cloned the repository; that adds pyarrow, which only reproduce.py needs.

Python Inference

Self-contained — nothing to clone, no local files to prepare.

import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from colpali_engine.models import ColQwen3_5, ColQwen3_5Processor

model_id = "tencent/EVIE-Preview-4.5B"


def enable_bidirectional_attention(model):
    """Encoder-ize the full-attention layers; the GatedDeltaNet layers stay recurrent."""
    for cfg in (model.config, getattr(model.config, "text_config", None)):
        if cfg is not None:
            cfg.is_causal = False
    for module in model.modules():
        if module.__class__.__name__ in ("Qwen3_5Attention", "Qwen3Attention"):
            if hasattr(module, "is_causal"):
                module.is_causal = False


# 1. Load model and enable bidirectional attention
model = ColQwen3_5.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="cuda",
    attn_implementation="flash_attention_2",
).eval()
enable_bidirectional_attention(model)

# 2. Load processor
processor = ColQwen3_5Processor.from_pretrained(model_id)

# 3. Prepare inputs — four example document pages
pages = [
    hf_hub_download("sentence-transformers/example-documents", f"doc{i}.jpg", repo_type="dataset")
    for i in range(1, 5)
]
images = [Image.open(p).convert("RGB") for p in pages]
queries = [
    "What is the variable represented on the y-axis of the graph?",
    "Total outlay is maximum in which year?",
]

image_batch = processor.process_images(images).to(model.device)
query_batch = processor.process_queries(queries).to(model.device)

# 4. Generate multi-vector embeddings and score
with torch.inference_mode():
    image_embeddings = model(**image_batch)
    model.rope_deltas = None  # required before query forward
    query_embeddings = model(**query_batch)

scores = processor.score(query_embeddings, image_embeddings)
print(scores)
# tensor([[17.3750, 10.9375,  7.8750,  7.3438],
#         [ 6.5938, 13.3750,  6.2188,  6.0938]])
print("Best page per query:", scores.argmax(dim=1))
# Best page per query: tensor([0, 1])

⚠️ Apply enable_bidirectional_attention(model) once after loading, and reset model.rope_deltas = None before every query forward pass. Both are required to reach the scores above — released colpali-engine (through 0.3.17) builds ColQwen3.5 with causal masks, which costs about 1.1 on top-hit MaxSim. The same helper ships as bidirectional.py for infer.py and reproduce.py.

CLI

python infer.py --query "Quarterly revenue report" --image page_1.png --image page_2.png

Sentence Transformers

EVIE also loads as a Sentence Transformers MultiVectorEncoder, exposing the familiar encode_query / encode_document / similarity API with MaxSim scoring built in. Bidirectional attention is baked into the shipped configuration, so no extra call is needed.

MultiVectorEncoder requires Sentence Transformers 6.0.0, which is not on PyPI yet — install from source until it is released:

pip install "sentence-transformers[image] @ git+https://github.com/huggingface/sentence-transformers.git"

from sentence_transformers import MultiVectorEncoder

model = MultiVectorEncoder("tencent/EVIE-Preview-4.5B")

queries = [
    "What is the variable represented on the y-axis of the graph?",
    "Total outlay is maximum in which year?",
]
documents = [
    "https://huggingface.co/datasets/sentence-transformers/example-documents/resolve/main/doc1.jpg",
    "https://huggingface.co/datasets/sentence-transformers/example-documents/resolve/main/doc2.jpg",
    "https://huggingface.co/datasets/sentence-transformers/example-documents/resolve/main/doc3.jpg",
    "https://huggingface.co/datasets/sentence-transformers/example-documents/resolve/main/doc4.jpg",
]

query_embeddings = model.encode_query(queries)
document_embeddings = model.encode_document(documents)
print(query_embeddings[0].shape, document_embeddings[0].shape)
# torch.Size([23, 128]) torch.Size([755, 128])

scores = model.similarity(query_embeddings, document_embeddings)
print(scores)
# tensor([[17.3457, 10.8008,  7.8613,  7.3174],
#         [ 6.5547, 13.3828,  6.2207,  6.0771]])
print("Best page per query:", scores.argmax(dim=1))
# Best page per query: tensor([0, 1])

Both paths above run on the same four example pages, so they are directly comparable. The two sets of scores agree closely; the small differences come from the attention backend and dtype, and the ranking is identical.

Documents may be file paths, URLs or PIL.Image objects. Text passed to encode_document is rendered as a query, since this model has no separate text-document format.

The default page budget is the 768-token tier. To score the 1,792-token tier, raise the pixel budget through processor_kwargs:

model = MultiVectorEncoder(
    "tencent/EVIE-Preview-4.5B",
    model_kwargs={"attn_implementation": "flash_attention_2", "device_map": "cuda:0"},
    processor_kwargs={"size": {"longest_edge": 1792 * 32 * 32, "shortest_edge": 65536}},
)

---

🔬 Reproducing

Every number on this card is reproducible with the shipped script across all visible GPUs:

bash reproduce.sh

On the first run, download_data.py fetches the 22 public ViDoRe datasets (~55 GB) from Hugging Face. To reuse an existing directory:

bash reproduce.sh /path/to/vidore

Target aggregates

ViDoRe V1        nDCG@5    91.73   (10 tasks)
ViDoRe V2        nDCG@5    70.87   (4 tasks)
ViDoRe V1+V2     nDCG@5    85.77   (14 tasks)
ViDoRe V3 public nDCG@10   64.56   (8 domains x 6 languages, 768 visual tokens)
ViDoRe V3 public nDCG@10   65.36   (8 domains x 6 languages, 1792 visual tokens)

To score the 1,792-token tier directly:

python -m torch.distributed.run --nproc_per_node=$(nvidia-smi -L | wc -l) reproduce.py \
  --boards v3 --max-visual-tokens 1792 --data-root /path/to/vidore

---

🎓 Training Details

EVIE was trained on approximately 0.8 million high-quality image-query pairs spanning multilingual documents, technical reports, complex financial tables, infographics and document visual QA.

Hard Negative Mining & Evidence Judging

Every mined negative is re-judged by a large multimodal judge before it reaches the loss:

• 🟢 Candidates that actually answer the query are promoted to positives.
• 🟡 Partially relevant or ambiguous candidates are masked out of the loss.
• 🔴 Only strictly irrelevant pages survive as true hard negatives.

Multi-positive rows are group-aware weighted by 1/positive_count so that positives from the same query never penalise each other in-batch. Rows with empty queries, corrupted images or degraded text are dropped.

---

🙏 Acknowledgements

• Built on the ColPali Engine by Illuin Technology.
• Powered by the Qwen3.5-4B vision-language backbone.
• Evaluated on the ViDoRe Benchmark family.

---

📚 Citation

@misc{tencent2026evie,
  title        = {EVIE-Preview-4.5B: Rank-1 Multilingual Visual Document Retrieval with 128-Dimensional Multi-Vector Embeddings},
  author       = {{Tencent}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/tencent/EVIE-Preview-4.5B}}
}

🏆 Rank #1 on ViDoRe V3 · 🏆 Rank #1 on ViDoRe V1+V2 · 💾 native 128D token vectors