init

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

1_LogitScore/config.json

@@ -0,0 +1,5 @@
+{
+    "true_token_id": 9693,
+    "false_token_id": 2152,
+    "module_input_name": "causal_logits"
+}

README.md

@@ -0,0 +1,226 @@
+---
+license: apache-2.0
+library_name: transformers
+pipeline_tag: text-ranking
+language:
+- en
+base_model:
+- Qwen/Qwen3-VL-2B-Instruct
+tags:
+- sentence-transformers
+- transformers
+- multimodal rerank
+- text rerank
+- conversational
+---
+# RenderRank
+
+**Learning to Rerank Text through Visual Compression**
+
+RenderRank converts text into compact visual token sequences by rendering it as images. This change in input modality reduces the number of tokens used to represent documents, allowing more content to fit within the same context budget. Queries remain text, and relevance is scored against the visual document representations.
+
+[![RenderRank architecture: text queries and visually encoded documents for relevance scoring](assets/struc.png)](assets/struc.pdf)
+
+## Highlights
+
+- **Text as visual tokens:** represent document text through rendered images instead of conventional text token sequences.
+- **Shorter input sequences:** compact visual representations reduce input length and allow more document content within a fixed context budget.
+- **Three input modes:** score document text directly with `text`, render it automatically with `render`, or provide existing document pages with `image`.
+
+| Property | Value |
+| :--- | :--- |
+| Model type | Pairwise document reranker |
+| Architecture | Qwen3-VL |
+| Parameters | Approximately 2.1B, including the vision encoder |
+| Language evaluated | English |
+| Maximum context length | 32,768 tokens, including query, template, document text, and visual tokens |
+| Scoring | Yes/no relevance scoring |
+
+## BEIR Performance
+
+All rerankers score the top 100 BM25 candidates for each query. Baselines use text queries and documents; RenderRank uses text queries and documents rendered with the default 12pt configuration below. Scores are NDCG@10; Avg. is the mean across 11 datasets. Tokens is the mean input length per query–document pair before truncation, averaged across the same datasets. For RenderRank, this includes both textual and visual tokens.
+
+| Model | AA | CFV | DBP | FQA | FVR | HQA | NFC | SD | SF | TC | TCH | Avg. | Tokens |
+| :--- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| gte-reranker-modernbert-base | 66.14 | 25.80 | 42.10 | 42.54 | 89.84 | 76.15 | 34.81 | 18.90 | 75.81 | 79.66 | 33.44 | 53.20 | 359.25 |
+| mxbai-rerank-large-v1 | 16.16 | 25.61 | 45.37 | 40.29 | 82.19 | 71.58 | 37.32 | 18.96 | 75.26 | 85.84 | 37.44 | 48.73 | 347.45 |
+| bge-reranker-large | 30.94 | 34.11 | 44.21 | 37.47 | 89.30 | 80.09 | 33.91 | 16.68 | 73.98 | 73.21 | 34.69 | 49.87 | 409.32 |
+| LAMAR-600m | 66.21 | 36.21 | 46.23 | 41.14 | 89.49 | 79.14 | 35.04 | 20.22 | 76.97 | 80.65 | 35.76 | 55.19 | 409.32 |
+| Qwen3-Reranker-0.6B | 68.04 | 34.34 | 43.76 | 39.74 | 87.13 | 77.25 | 36.60 | 20.44 | 77.00 | 85.54 | 30.32 | 54.56 | 438.70 |
+| llama-nemotron-rerank-1b-v2 | 54.29 | 27.37 | 45.13 | 47.11 | 87.66 | 80.34 | 38.14 | 21.53 | 79.82 | 83.14 | 32.47 | 54.27 | 363.99 |
+| mxbai-rerank-large-v2 | 42.23 | 23.03 | 38.01 | 28.85 | 70.84 | 69.50 | 35.17 | 17.49 | 78.81 | 67.78 | 46.94 | 47.15 | 449.76 |
+| LightOn-rerank-PW-2B | 45.52 | 23.21 | 42.60 | 35.66 | 86.51 | 73.05 | 35.61 | 16.64 | 77.70 | 81.24 | 36.91 | 50.42 | 416.22 |
+| bge-reranker-v2-gemma | 74.98 | 32.03 | 45.01 | 43.18 | 87.45 | 80.47 | 36.25 | 19.58 | 77.43 | 80.08 | 37.56 | 55.82 | 399.11 |
+| Qwen3-Reranker-4B | 75.40 | 37.84 | 47.02 | 44.63 | 89.14 | 79.06 | 37.48 | 23.59 | 79.47 | 85.47 | 38.77 | 57.99 | 438.70 |
+| zerank-2-reranker | 44.87 | 23.65 | 44.95 | 42.75 | 83.22 | 70.97 | 38.50 | 20.23 | 79.35 | 85.24 | 38.10 | 51.98 | 380.69 |
+| LightOn-rerank-PW-4B | 52.50 | 28.24 | 44.80 | 40.27 | 87.70 | 72.79 | 37.33 | 17.29 | 76.72 | 79.54 | 36.70 | 52.17 | 416.22 |
+| **RenderRank (Ours)** | 69.11 | 35.91 | 46.19 | 42.66 | 88.92 | 78.60 | 37.31 | 20.75 | 77.00 | 84.82 | 34.27 | **55.96** | **290.07** |
+
+AA: ArguAna; CFV: Climate-FEVER; DBP: DBPedia; FQA: FiQA; FVR: FEVER; HQA: HotpotQA; NFC: NFCorpus; SD: SCIDOCS; SF: SciFact; TC: TREC-COVID; TCH: Touché-2020.
+
+## Long-Document Performance
+
+Results on the English subset of MLDR and three LongEmbed datasets: 2WikiMQA, QMSum, and SummScreenFD. The comparison includes models supporting at least 16K input tokens. MLDR follows the MMTEB reranking protocol; for LongEmbed, each query reranks eight candidates retrieved with Qwen3-Embedding-0.6B.
+
+Each dataset cell shows NDCG@10 followed by the average input token count in brackets: **score [tokens]**. Token counts are measured per query–document pair before truncation and include both textual and visual tokens for RenderRank. Avg. reports the mean score across the four datasets.
+
+| Model | MLDR | 2WikiMQA | QMSum | SummScreenFD | Avg. |
+| :--- | ---: | ---: | ---: | ---: | ---: |
+| Qwen3-Reranker-0.6B | 99.63 [8863.4] | 94.54 [9230.2] | 56.43 [13543.6] | 98.25 [8606.3] | 87.21 |
+| LightOn-rerank-PW-2B | 98.91 [8878.0] | 71.27 [9230.1] | 54.30 [13876.6] | 93.05 [8977.2] | 79.38 |
+| Qwen3-Reranker-4B | 99.85 [8863.4] | 94.54 [9230.2] | 59.11 [13543.6] | 99.11 [8606.3] | 88.15 |
+| zerank-2-reranker | 99.57 [8805.6] | 94.42 [9173.1] | 60.10 [13485.9] | 98.97 [8548.5] | 88.26 |
+| LightOn-rerank-PW-4B | 99.68 [8878.0] | 93.84 [9230.1] | 58.87 [13876.6] | 98.91 [8977.2] | 87.82 |
+| **RenderRank (Ours)** | 99.74 [4198.0] | 94.30 [4262.2] | 59.94 [6388.8] | 99.10 [3701.9] | 88.27 |
+
+## Usage
+
+The examples load the model from `nlpai-lab/RenderRank-2B` on Hugging Face.
+
+The model applies its reranking chat template internally. Pass the instruction as shown below; do not manually prepend a chat template to the document.
+
+### Rendering
+
+With Transformers, `{"render": document_text}` automatically renders the document before scoring. The font is included in this repository.
+
+For Sentence Transformers, use the bundled `rendering.py` to create a list of PIL page images first:
+
+```python
+import sys
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+
+repo_dir = Path(snapshot_download(
+    "nlpai-lab/RenderRank-2B",
+    allow_patterns=["rendering.py", "Roboto-Regular.ttf"],
+))
+sys.path.insert(0, str(repo_dir))
+from rendering import DocumentImageConfig, DocumentImageRenderer
+
+renderer = DocumentImageRenderer(
+    DocumentImageConfig(font_path=repo_dir / "Roboto-Regular.ttf")
+)
+pages = renderer.render_document("Paris is the capital of France.")
+# pages is a list of PIL images, in document order.
+```
+
+The returned PIL images can be passed directly as image content or saved as numbered page files. The Transformers `render` mode calls this renderer internally, so no separate rendering step is needed there.
+
+| Setting | Value |
+| :--- | :--- |
+| Font | Roboto Regular |
+| Font size | 12pt at 96 DPI (16px) |
+| Line spacing | 1.0 (16px line height) |
+| Page width | 896px |
+| Page height | 32–896px, rounded up to a multiple of 32px |
+| Lines per page | Up to 56 |
+| Margins | 0px on all sides |
+| Colors | Black text on a white background |
+| Rendering | Pillow default text antialiasing |
+
+Whitespace, including paragraph breaks and tabs, is normalized to a single space. Lines wrap according to the font's actual pixel width; words wider than the page are split by character. Overflow continues onto subsequent pages without overlap. The final page is sized to its content, and empty documents produce one 896 × 32px page.
+
+All generated pages are supplied in order as one document, producing one relevance score. Rendering is not limited to the first page.
+
+### Sentence Transformers
+
+Use a Sentence Transformers version supporting multimodal `CrossEncoder` models.
+
+```bash
+pip install -U sentence-transformers
+```
+
+The same call can score text, a single document image, and multiple page images. In the example below, `1.png`, `2.png`, and `3.png` are ordered pages of one document.
+
+```python
+import torch
+from PIL import Image
+from sentence_transformers import CrossEncoder
+
+model = CrossEncoder(
+    "nlpai-lab/RenderRank-2B",
+    device="cuda",
+    max_length=32768,
+    model_kwargs={"dtype": torch.bfloat16},
+)
+
+query = "What is the capital of France?"
+documents = [
+    [{"type": "text", "text": "Paris is the capital of France."}],
+    [{"type": "image", "image": Image.open("/path/to/document.png")}],
+    [
+        {"type": "image", "image": Image.open("/path/to/1.png")},
+        {"type": "image", "image": Image.open("/path/to/2.png")},
+        {"type": "image", "image": Image.open("/path/to/3.png")},
+        # Add further pages here in document order.
+    ],
+]
+messages = [
+    [
+        {"role": "query", "content": [{"type": "text", "text": query}]},
+        {"role": "document", "content": document},
+    ]
+    for document in documents
+]
+
+scores = model.predict(
+    messages,
+    prompt="Retrieve text relevant to the user's query.",
+    batch_size=1,
+)
+print(scores)  # One score per document, not per page.
+```
+
+Larger scores indicate greater relevance. Scores are the difference between the yes and no logits, as used in our evaluation. Sentence Transformers requires one image content entry per page; `render` and `{"image": [page1, page2]}` are supported by the Transformers interface below, not this interface.
+
+### Transformers
+
+This repository provides a custom `AutoModel` entry point with a `process()` method. It supports all three document input modes.
+
+**Requirements**
+
+The Transformers interface was tested with the following versions:
+
+```text
+transformers==5.9.0
+qwen-vl-utils==0.0.14
+torch==2.11.0
+torchvision==0.26.0
+scipy
+```
+
+`qwen-vl-utils` handles image preparation in this interface; `scipy` is used for score normalization. NumPy and Pillow are installed through the dependencies above. Install PyTorch and torchvision builds matching your CUDA environment.
+
+```python
+import torch
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained(
+    "nlpai-lab/RenderRank-2B",
+    trust_remote_code=True,
+    dtype=torch.bfloat16,
+).to("cuda").eval()
+
+inputs = {
+    "instruction": "Retrieve text relevant to the user's query.",
+    "query": {"text": "What is the capital of France?"},
+    "documents": [
+        # Score text directly.
+        {"text": "Paris is the capital of France."},
+        # Render text into document pages, then score the images.
+        {"render": "Paris is the capital of France."},
+        # Score an existing document image.
+        {"image": "/path/to/document.png"},
+        # Score multiple ordered pages as one document.
+        {"image": ["/path/to/page1.png", "/path/to/page2.png"]},
+    ],
+}
+
+with torch.inference_mode():
+    scores = model.process(inputs)
+
+ranked_indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)
+print(scores)         # One score in [0, 1] per document, in input order.
+print(ranked_indices)
+```

Roboto-Regular.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:797e35f7f5d6020a5c6ea13b42ecd668bcfb3bbc4baa0e74773527e5b6cb3174
+size 305608

additional_chat_templates/reranker.jinja

@@ -0,0 +1,52 @@
+{%- set default_instruction = "Given a search query, retrieve relevant candidates that answer the query." -%}
+{%- set ns = namespace(instruction="", found_instruction=false) -%}
+{%- for message in messages -%}
+    {%- if message.role == "system" -%}
+        {%- if message.content is string -%}
+            {%- set ns.instruction = message.content -%}
+        {%- else -%}
+            {%- for content in message.content -%}
+                {%- if 'text' in content -%}
+                    {%- set ns.instruction = ns.instruction + content.text -%}
+                {%- endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+        {%- set ns.found_instruction = true -%}
+    {%- endif -%}
+{%- endfor -%}
+{%- if not ns.found_instruction -%}
+    {%- set ns.instruction = default_instruction -%}
+{%- endif -%}
+{%- set image_count = namespace(value=0) -%}
+{%- set video_count = namespace(value=0) -%}
+{%- macro render_multimodal(message) -%}
+    {%- if message.content is string -%}
+        {{- message.content -}}
+    {%- else -%}
+        {%- for content in message.content -%}
+            {%- if content.type == 'image' or 'image' in content or 'image_url' in content -%}
+                {%- set image_count.value = image_count.value + 1 -%}
+                {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                <|vision_start|><|image_pad|><|vision_end|>
+            {%- elif content.type == 'video' or 'video' in content -%}
+                {%- set video_count.value = video_count.value + 1 -%}
+                {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                <|vision_start|><|video_pad|><|vision_end|>
+            {%- elif 'text' in content -%}
+                {{- content.text -}}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- endif -%}
+{%- endmacro -%}
+{{- '<|im_start|>system\nJudge whether the Document meets the requirements based on the Query and the Instruct provided. Note that the answer can only be "yes" or "no".<|im_end|>\n<|im_start|>user\n<Instruct>: ' + ns.instruction + '<Query>:' -}}
+{%- for message in messages if message.role == "query" -%}
+    {{- render_multimodal(message) -}}
+{%- endfor -%}
+{{- '\n<Document>:' -}}
+{%- for message in messages if message.role == "document" -%}
+    {{- render_multimodal(message) -}}
+{%- endfor -%}
+{{- '<|im_end|>\n' -}}
+{%- if add_generation_prompt -%}
+    {{- '<|im_start|>assistant\n' -}}
+{%- endif -%}

chat_template.jinja

@@ -0,0 +1,120 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' }}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- for message in messages %}
+    {%- if message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content_item in message.content %}
+                {%- if 'text' in content_item %}
+                    {{- content_item.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and message.content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

config.json

@@ -0,0 +1,72 @@
+{
+  "auto_map": {
+    "AutoModel": "modeling_renderrank.RenderRank"
+  },
+  "architectures": [
+    "Qwen3VLForConditionalGeneration"
+  ],
+  "dtype": "bfloat16",
+  "hidden_size": 2048,
+  "image_token_id": 151655,
+  "model_type": "qwen3_vl",
+  "pad_token_id": 151643,
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "bos_token_id": 151643,
+    "dtype": "bfloat16",
+    "eos_token_id": 151645,
+    "head_dim": 128,
+    "hidden_act": "silu",
+    "hidden_size": 2048,
+    "initializer_range": 0.02,
+    "intermediate_size": 6144,
+    "max_position_embeddings": 262144,
+    "model_type": "qwen3_vl_text",
+    "num_attention_heads": 16,
+    "num_hidden_layers": 28,
+    "num_key_value_heads": 8,
+    "pad_token_id": 151643,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "mrope_interleaved": true,
+      "mrope_section": [
+        24,
+        20,
+        20
+      ],
+      "rope_theta": 5000000,
+      "rope_type": "default"
+    },
+    "tie_word_embeddings": true,
+    "use_cache": false,
+    "vocab_size": 151936
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.14.1",
+  "video_token_id": 151656,
+  "vision_config": {
+    "deepstack_visual_indexes": [
+      5,
+      11,
+      17
+    ],
+    "depth": 24,
+    "dtype": "bfloat16",
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1024,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 4096,
+    "model_type": "qwen3_vl_vision",
+    "num_heads": 16,
+    "num_position_embeddings": 2304,
+    "out_hidden_size": 2048,
+    "pad_token_id": 151643,
+    "patch_size": 16,
+    "spatial_merge_size": 2,
+    "temporal_patch_size": 2
+  },
+  "vision_end_token_id": 151653,
+  "vision_start_token_id": 151652
+}

config_sentence_transformers.json

@@ -0,0 +1,13 @@
+{
+  "__version__": {
+    "pytorch": "2.11.0+cu129",
+    "sentence_transformers": "5.7.0.dev0",
+    "transformers": "5.14.1"
+  },
+  "activation_fn": "torch.nn.modules.linear.Identity",
+  "default_prompt_name": "query",
+  "model_type": "CrossEncoder",
+  "prompts": {
+    "query": "Retrieve text relevant to the user's query."
+  }
+}

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 151643,
+  "do_sample": true,
+  "eos_token_id": [
+    151645,
+    151643
+  ],
+  "pad_token_id": 151643,
+  "temperature": 0.7,
+  "top_k": 20,
+  "top_p": 0.8,
+  "transformers_version": "5.14.1"
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0add172e901d1f99bd2cd42a1a3e38b2d2016788862386961456019dd4346fff
+size 4255140312

modeling_renderrank.py

@@ -0,0 +1,66 @@
+"""AutoModel entry point: render preprocessing plus Qwen's existing scorer."""
+from pathlib import Path
+
+from transformers import AutoProcessor, Qwen3VLForConditionalGeneration
+from transformers.utils.hub import cached_file
+
+from .qwen3_vl_reranker import Qwen3VLReranker
+from .rendering import DocumentImageConfig, DocumentImageRenderer, prepare_render_inputs
+
+
+class _QwenScorer(Qwen3VLReranker):
+    def tokenize(self, pairs, **kwargs):
+        inputs = super().tokenize(pairs, **kwargs)
+        # Transformers 5 adds modality IDs. Align them with the upstream's
+        # finalized input IDs, then convert every model input to tensors.
+        if "mm_token_type_ids" in inputs:
+            inputs["mm_token_type_ids"] = self.processor.create_mm_token_type_ids(
+                inputs["input_ids"].tolist()
+            )
+        return inputs.convert_to_tensors("pt")
+
+
+class RenderRank(Qwen3VLForConditionalGeneration):
+    """Keep the checkpoint architecture; expose the official process API."""
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, *args, **kwargs):
+        loaded = super().from_pretrained(pretrained_model_name_or_path, *args, **kwargs)
+        model = loaded[0] if isinstance(loaded, tuple) else loaded
+        asset_kwargs = {
+            key: kwargs[key] for key in
+            ("cache_dir", "revision", "token", "local_files_only", "subfolder", "force_download")
+            if key in kwargs
+        }
+        model.processor = AutoProcessor.from_pretrained(
+            pretrained_model_name_or_path, padding_side="left", **asset_kwargs
+        )
+        model._render_font_path = cached_file(
+            pretrained_model_name_or_path, "Roboto-Regular.ttf", **asset_kwargs
+        )
+        return loaded
+
+    def process(self, inputs):
+        """Return scores in document order; render is only an input conversion."""
+        if not isinstance(inputs, dict):
+            raise TypeError("inputs must be a dictionary")
+        renderer = DocumentImageRenderer(DocumentImageConfig(Path(self._render_font_path)))
+        prepared = prepare_render_inputs(inputs, renderer)
+
+        # Bind the official wrapper to the already-loaded model (no second load).
+        scorer = _QwenScorer.__new__(_QwenScorer)
+        scorer.model = self.model
+        scorer.processor = self.processor
+        scorer.device = self.device
+        scorer.max_length = 32768
+        scorer.min_pixels = self.processor.image_processor.size["shortest_edge"]
+        scorer.max_pixels = self.processor.image_processor.size["longest_edge"]
+        scorer.total_pixels = 10 * 768 * 32 * 32
+        scorer.fps = 1
+        scorer.num_frames = 64
+        scorer.max_frames = 64
+        scorer.default_instruction = "Retrieve text relevant to the user's query."
+        vocab = self.processor.tokenizer.get_vocab()
+        scorer.score_linear = scorer.get_binary_linear(self, vocab["yes"], vocab["no"])
+        scorer.score_linear = scorer.score_linear.to(device=self.device, dtype=self.dtype).eval()
+        return scorer.process(prepared)

modules.json

@@ -0,0 +1,14 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.base.modules.transformer.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_LogitScore",
+    "type": "sentence_transformers.cross_encoder.modules.logit_score.LogitScore"
+  }
+]

processor_config.json

@@ -0,0 +1,62 @@
+{
+  "image_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_processor_type": "Qwen2VLImageProcessor",
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "merge_size": 2,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {
+      "longest_edge": 802816,
+      "shortest_edge": 4096
+    },
+    "temporal_patch_size": 2
+  },
+  "processor_class": "Qwen3VLProcessor",
+  "video_processor": {
+    "data_format": "channels_first",
+    "default_to_square": true,
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": true,
+    "fps": 2,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "max_frames": 768,
+    "merge_size": 2,
+    "min_frames": 4,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "size": {
+      "longest_edge": 25165824,
+      "shortest_edge": 4096
+    },
+    "temporal_patch_size": 2,
+    "video_processor_type": "Qwen3VLVideoProcessor"
+  }
+}

qwen3_vl_reranker.py

@@ -0,0 +1,314 @@
+# Based on Qwen/Qwen3-VL-Reranker-2B, Hugging Face revision 4bd860a.
+# Apache-2.0. Changes: ordered multi-image input and frame-helper call repair.
+import torch
+import numpy as np
+import logging
+
+from PIL import Image
+from scipy import special
+from typing import List
+from qwen_vl_utils import process_vision_info
+from transformers import Qwen3VLForConditionalGeneration, AutoProcessor
+
+logger = logging.getLogger(__name__)
+
+MAX_LENGTH = 8192
+IMAGE_BASE_FACTOR = 16
+IMAGE_FACTOR = IMAGE_BASE_FACTOR * 2
+MIN_PIXELS = 4 * IMAGE_FACTOR * IMAGE_FACTOR  # 4 tokens
+MAX_PIXELS = 1280 * IMAGE_FACTOR * IMAGE_FACTOR  # 1280 tokens
+MAX_RATIO = 200
+
+FRAME_FACTOR = 2
+FPS = 1
+MIN_FRAMES = 2
+MAX_FRAMES = 64
+MIN_TOTAL_PIXELS = 1 * FRAME_FACTOR * MIN_PIXELS  # 1 frames
+MAX_TOTAL_PIXELS = 4 * FRAME_FACTOR * MAX_PIXELS  # 4 frames
+
+
+def sample_frames(frames, num_segments, max_segments):
+    duration = len(frames)
+    frame_id_array = np.linspace(0, duration - 1, num_segments, dtype=int)
+    frame_id_list = frame_id_array.tolist()
+    last_frame_id = frame_id_list[-1]
+
+    sampled_frames = []
+    for frame_idx in frame_id_list:
+        try:
+            single_frame_path = frames[frame_idx]
+        except:
+            break
+        sampled_frames.append(single_frame_path)
+    # Pad with last frame if total frames less than num_segments
+    while len(sampled_frames) < num_segments:
+        sampled_frames.append(frames[last_frame_id])
+    return sampled_frames[:max_segments]
+
+class Qwen3VLReranker():
+    def __init__(
+        self,
+        model_name_or_path: str,
+        max_length: int = MAX_LENGTH,
+        min_pixels: int = MIN_PIXELS,
+        max_pixels: int = MAX_PIXELS,
+        total_pixels: int = MAX_TOTAL_PIXELS,
+        fps: float = FPS,
+        num_frames: int = MAX_FRAMES,
+        max_frames: int = MAX_FRAMES,
+        default_instruction: str = "Given a search query, retrieve relevant candidates that answer the query.",
+        **kwargs,
+    ):
+
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        self.max_length = max_length
+        self.min_pixels = min_pixels
+        self.max_pixels = max_pixels
+        self.total_pixels = total_pixels
+        self.fps = fps
+        self.num_frames = num_frames
+        self.max_frames = max_frames
+
+        self.default_instruction = default_instruction
+
+        lm = Qwen3VLForConditionalGeneration.from_pretrained(
+            model_name_or_path,
+            trust_remote_code=True, **kwargs
+        ).to(self.device)
+
+        self.model = lm.model
+        self.processor = AutoProcessor.from_pretrained(
+            model_name_or_path, trust_remote_code=True,
+            padding_side='left'
+        )
+        self.model.eval()
+
+        token_true_id = self.processor.tokenizer.get_vocab()["yes"]
+        token_false_id = self.processor.tokenizer.get_vocab()["no"]
+        self.score_linear = self.get_binary_linear(lm, token_true_id, token_false_id)
+        self.score_linear.eval()
+        self.score_linear.to(self.device).to(self.model.dtype)
+
+    def get_binary_linear(self, model, token_yes, token_no):
+
+        lm_head_weights = model.lm_head.weight.data
+
+        weight_yes = lm_head_weights[token_yes]
+        weight_no = lm_head_weights[token_no]
+
+        D = weight_yes.size()[0]
+        linear_layer = torch.nn.Linear(D, 1, bias=False)
+        with torch.no_grad():
+            linear_layer.weight[0] = weight_yes - weight_no
+        return linear_layer
+
+    @torch.no_grad()
+    def compute_scores(self, inputs):
+        batch_scores = self.model(**inputs).last_hidden_state[:, -1]
+        scores = self.score_linear(batch_scores)
+        scores = torch.sigmoid(scores).squeeze(-1).cpu().detach().tolist()
+        return scores
+
+    def truncate_tokens_optimized(
+        self,
+        tokens: List[str],
+        max_length: int,
+        special_tokens: List[str]
+    ) -> List[str]:
+        if len(tokens) <= max_length:
+            return tokens
+
+        special_tokens_set = set(special_tokens)
+
+        # Calculate budget: how many non-special tokens we can keep
+        num_special = sum(1 for token in tokens if token in special_tokens_set)
+        num_non_special_to_keep = max_length - num_special
+
+        # Build final list according to budget
+        final_tokens = []
+        non_special_kept_count = 0
+        for token in tokens:
+            if token in special_tokens_set:
+                final_tokens.append(token)
+            elif non_special_kept_count < num_non_special_to_keep:
+                final_tokens.append(token)
+                non_special_kept_count += 1
+
+        return final_tokens
+
+    def tokenize(self, pairs: list, **kwargs):
+        max_length = self.max_length
+        text = self.processor.apply_chat_template(pairs, tokenize=False, add_generation_prompt=True)
+        try:
+            images, videos, video_kwargs = process_vision_info(
+                pairs, image_patch_size=16, 
+                return_video_kwargs=True, 
+                return_video_metadata=True
+            )
+        except Exception as e:
+            logger.error(f"Error in processing vision info: {e}")
+            images = None
+            videos = None
+            video_kwargs = {'do_sample_frames': False}
+            text = self.processor.apply_chat_template(
+                [{'role': 'user', 'content': [{'type': 'text', 'text': 'NULL'}]}], 
+                add_generation_prompt=True, tokenize=False
+            )
+        
+        if videos is not None:
+            videos, video_metadatas = zip(*videos)
+            videos, video_metadatas = list(videos), list(video_metadatas)
+        else:
+            video_metadatas = None
+        inputs = self.processor(
+            text=text,
+            images=images,
+            videos=videos,
+            video_metadata=video_metadatas,
+            truncation=False,
+            padding=False,
+            do_resize=False,
+            **video_kwargs
+        )
+        for i, ele in enumerate(inputs['input_ids']):
+            inputs['input_ids'][i] = self.truncate_tokens_optimized(
+                inputs['input_ids'][i][:-5], max_length,
+                self.processor.tokenizer.all_special_ids
+            ) + inputs['input_ids'][i][-5:]
+        temp_inputs = self.processor.tokenizer.pad(
+            {'input_ids': inputs['input_ids']}, padding=True,
+            return_tensors="pt", max_length=self.max_length
+        )
+        for key in temp_inputs:
+            inputs[key] = temp_inputs[key]
+        return inputs
+
+    def format_mm_content(
+        self, 
+        text, image, video, 
+        prefix='Query:', 
+        fps=None, max_frames=None,
+    ):
+        content = []
+
+        content.append({'type': 'text', 'text': prefix})
+        if not text and not image and not video:
+            content.append({'type': 'text', 'text': "NULL"})
+            return content
+
+        if video:
+            video_content = None
+            video_kwargs = { 'total_pixels': self.total_pixels }
+            if isinstance(video, list):
+                video_content = video
+                if self.num_frames is not None or self.max_frames is not None:
+                    video_content = sample_frames(video_content, self.num_frames or len(video_content), self.max_frames or len(video_content))
+                video_content = [
+                    ('file://' + ele if isinstance(ele, str) else ele) 
+                    for ele in video_content
+                ]
+            elif isinstance(video, str):
+                video_content = video if video.startswith(('http://', 'https://')) else 'file://' + video
+                video_kwargs = {'fps': fps or self.fps, 'max_frames': max_frames or self.max_frames,}
+            else:
+                raise TypeError(f"Unrecognized video type: {type(video)}")
+
+            if video_content:
+                content.append({
+                    'type': 'video', 'video': video_content,
+                    **video_kwargs
+                })
+
+        # RenderRank: one document may contain multiple ordered page images.
+        for image in (image if isinstance(image, list) else [image] if image is not None else []):
+            image_content = None
+            if isinstance(image, Image.Image):
+                image_content = image
+            elif isinstance(image, str):
+                image_content = image if image.startswith(('http', 'oss')) else 'file://' + image
+            else:
+                raise TypeError(f"Unrecognized image type: {type(image)}")
+
+            if image_content:
+                content.append({
+                    'type': 'image', 'image': image_content,
+                    "min_pixels": self.min_pixels,
+                    "max_pixels": self.max_pixels
+                })
+
+        if text:
+            content.append({'type': 'text', 'text': text})
+        return content
+
+    def format_mm_instruction(
+        self, 
+        query_text, query_image, query_video, 
+        doc_text, doc_image, doc_video,
+        instruction=None, 
+        fps=None, max_frames=None
+    ):
+        inputs = []
+        inputs.append({
+            "role": "system",
+            "content": [{
+                "type": "text",
+                "text": "Judge whether the Document meets the requirements based on the Query and the Instruct provided. Note that the answer can only be \"yes\" or \"no\"."
+            }
+            ]
+        })
+        if isinstance(query_text, tuple):
+            instruct, query_text = query_text
+        else:
+            instruct = instruction
+        contents = []
+        contents.append({
+            "type": "text",
+            "text": '<Instruct>: ' + instruct
+        })
+        query_content = self.format_mm_content(
+            query_text, query_image, query_video, prefix='<Query>:', 
+            fps=fps, max_frames=max_frames
+        )
+        contents.extend(query_content)
+        doc_content = self.format_mm_content(
+            doc_text, doc_image, doc_video, prefix='\n<Document>:', 
+            fps=fps, max_frames=max_frames
+        )
+        contents.extend(doc_content)
+        inputs.append({
+            "role": "user",
+            "content": contents
+        })
+        return inputs
+
+    def process(
+        self,
+        inputs,
+    ) -> list[torch.Tensor]:
+        instruction = inputs.get('instruction', self.default_instruction)
+
+        query = inputs.get("query", {})
+        documents = inputs.get("documents", [])
+        if not query or not documents:
+            return []
+
+        pairs = [self.format_mm_instruction(
+            query.get('text', None),
+            query.get('image', None),
+            query.get('video', None),
+            document.get('text', None),
+            document.get('image', None),
+            document.get('video', None),
+            instruction=instruction,
+            fps=inputs.get('fps', self.fps),
+            max_frames=inputs.get('max_frames', self.max_frames)
+        ) for document in documents]
+
+        final_scores = []
+        for pair in pairs:
+            inputs = self.tokenize([pair])
+            inputs = inputs.to(self.model.device)
+            scores = self.compute_scores(inputs)
+            final_scores.extend(scores)
+        return final_scores

rendering.py

@@ -0,0 +1,239 @@
+"""Existing evaluation renderer, packaged without evaluation/cache dependencies."""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Sequence
+
+from PIL import Image, ImageDraw, ImageFont
+
+@dataclass(frozen=True)
+class DocumentImageConfig:
+    """Exact document rendering parameters used by the vision evaluation."""
+
+    font_path: Path
+    font_index: int = 0
+    font_family: str = "Roboto"
+    font_style: str = "Regular"
+    font_size_px: int = 16
+    dpi: int = 96
+    line_height_px: int | None = None
+    width_px: int = 896
+    min_height_px: int = 32
+    height_step_px: int = 32
+    max_height_px: int = 896
+    max_lines_per_page: int | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "font_path", Path(self.font_path))
+        line_height_px = self.font_size_px if self.line_height_px is None else self.line_height_px
+        object.__setattr__(self, "line_height_px", line_height_px)
+        max_lines_per_page = (
+            min(56, self.max_height_px // line_height_px)
+            if self.max_lines_per_page is None
+            else self.max_lines_per_page
+        )
+        object.__setattr__(self, "max_lines_per_page", max_lines_per_page)
+        numeric_values = {
+            "font_index": self.font_index,
+            "font_size_px": self.font_size_px,
+            "dpi": self.dpi,
+            "line_height_px": line_height_px,
+            "width_px": self.width_px,
+            "min_height_px": self.min_height_px,
+            "height_step_px": self.height_step_px,
+            "max_height_px": self.max_height_px,
+            "max_lines_per_page": max_lines_per_page,
+        }
+        for name, value in numeric_values.items():
+            if name == "font_index" and value < 0:
+                raise ValueError("font_index cannot be negative")
+            if name != "font_index" and value < 1:
+                raise ValueError(f"{name} must be positive")
+        if self.min_height_px > self.max_height_px:
+            raise ValueError("min_height_px cannot exceed max_height_px")
+        if self.min_height_px % self.height_step_px or self.max_height_px % self.height_step_px:
+            raise ValueError("page heights must be exact multiples of height_step_px")
+        if line_height_px * max_lines_per_page > self.max_height_px:
+            raise ValueError("max_lines_per_page does not fit in max_height_px")
+
+    def to_dict(self) -> dict[str, Any]:
+        rendering = {
+            "font": f"{self.font_family} {self.font_style}",
+            "font_path": str(self.font_path),
+            "font_size_px": self.font_size_px,
+            "dpi": self.dpi,
+            "line_height_px": self.line_height_px,
+            "width_px": self.width_px,
+            "min_height_px": self.min_height_px,
+            "height_step_px": self.height_step_px,
+            "max_height_px": self.max_height_px,
+            "max_lines_per_page": self.max_lines_per_page,
+            "margins_px": 0,
+            "background": "white",
+            "foreground": "black",
+            "whitespace_normalization": "all_runs_to_single_space",
+            "wrap_measurement": (
+                "roboto_pixel_width"
+                if self.font_family.casefold() == "roboto"
+                else "font_pixel_width"
+            ),
+            "overwide_word_split": "character",
+            "page_overlap": 0,
+        }
+        if self.font_index:
+            rendering["font_index"] = self.font_index
+        return rendering
+
+
+class DocumentImageRenderer:
+    """Normalize, pixel-wrap, paginate, and render document text."""
+
+    def __init__(self, config: DocumentImageConfig) -> None:
+        self.config = config
+        if not config.font_path.is_file():
+            raise FileNotFoundError(f"font not found: {config.font_path}")
+        self.font = ImageFont.truetype(
+            str(config.font_path),
+            config.font_size_px,
+            index=config.font_index,
+        )
+        family, style = self.font.getname()
+        if (
+            family.casefold() != config.font_family.casefold()
+            or style.casefold() != config.font_style.casefold()
+        ):
+            raise ValueError(
+                f"{config.font_family} {config.font_style} is required, "
+                f"but {config.font_path} reports {family} {style}"
+            )
+
+    @staticmethod
+    def normalize_text(text: str) -> str:
+        return " ".join(str(text).split())
+
+    def text_length(self, text: str) -> float:
+        return self.font.getlength(text)
+
+    def draw_line(self, draw: ImageDraw.ImageDraw, line: str, y: int) -> None:
+        draw.text(
+            (0, y),
+            line,
+            font=self.font,
+            fill="black",
+            anchor="lt",
+        )
+
+    def rendering_metadata(self) -> dict[str, Any]:
+        return self.config.to_dict()
+
+    def _split_overwide_word(self, word: str, max_width: int) -> list[str]:
+        chunks: list[str] = []
+        offset = 0
+        while offset < len(word):
+            low, high = offset + 1, len(word)
+            best = offset
+            while low <= high:
+                middle = (low + high) // 2
+                if self.text_length(word[offset:middle]) <= max_width:
+                    best = middle
+                    low = middle + 1
+                else:
+                    high = middle - 1
+            if best == offset:
+                raise ValueError(
+                    f"width {max_width}px is narrower than one rendered character"
+                )
+            chunks.append(word[offset:best])
+            offset = best
+        return chunks
+
+    def wrap_text(self, text: str, *, max_width: int | None = None) -> list[str]:
+        max_width = self.config.width_px if max_width is None else max_width
+        if max_width < 1:
+            raise ValueError("max_width must be positive")
+        normalized = self.normalize_text(text)
+        if not normalized:
+            return []
+
+        lines: list[str] = []
+        current = ""
+        for word in normalized.split(" "):
+            if self.text_length(word) > max_width:
+                if current:
+                    lines.append(current)
+                    current = ""
+                chunks = self._split_overwide_word(word, max_width)
+                lines.extend(chunks[:-1])
+                current = chunks[-1]
+                continue
+
+            candidate = word if not current else f"{current} {word}"
+            if self.text_length(candidate) <= max_width:
+                current = candidate
+            else:
+                lines.append(current)
+                current = word
+        if current:
+            lines.append(current)
+        return lines
+
+    def paginate_lines(self, lines: Sequence[str]) -> list[list[str]]:
+        if not lines:
+            return [[]]
+        page_size = self.config.max_lines_per_page
+        return [list(lines[start : start + page_size]) for start in range(0, len(lines), page_size)]
+
+    def page_height(self, line_count: int) -> int:
+        if line_count < 0 or line_count > self.config.max_lines_per_page:
+            raise ValueError(
+                f"line_count must be between 0 and {self.config.max_lines_per_page}"
+            )
+        content_height = max(1, line_count) * self.config.line_height_px
+        stepped_height = math.ceil(content_height / self.config.height_step_px) * self.config.height_step_px
+        return min(
+            self.config.max_height_px,
+            max(self.config.min_height_px, stepped_height),
+        )
+
+    def render_document(self, text: str) -> list[Image.Image]:
+        lines = self.wrap_text(text)
+        rendered: list[Image.Image] = []
+        for page_lines in self.paginate_lines(lines):
+            image = Image.new(
+                "RGB",
+                (self.config.width_px, self.page_height(len(page_lines))),
+                "white",
+            )
+            draw = ImageDraw.Draw(image)
+            for line_index, line in enumerate(page_lines):
+                self.draw_line(draw, line, line_index * self.config.line_height_px)
+            rendered.append(image)
+        return rendered
+
+
+
+def prepare_render_inputs(inputs: dict, renderer: DocumentImageRenderer) -> dict:
+    """Convert render documents to images; leave query/instruction/scoring untouched."""
+    if not isinstance(inputs, dict):
+        raise TypeError("inputs must be a dictionary")
+    documents = inputs.get("documents", [])
+    if not isinstance(documents, list):
+        raise TypeError("documents must be a list")
+    converted = []
+    for document in documents:
+        if not isinstance(document, dict):
+            raise TypeError("each document must be a dictionary")
+        if "render" not in document:
+            converted.append(document)
+            continue
+        if any(key in document for key in ("text", "image", "video")):
+            raise ValueError("render cannot be combined with text, image, or video")
+        if not isinstance(document["render"], str):
+            raise TypeError("render must contain document text as a string")
+        converted.append({
+            **{key: value for key, value in document.items() if key != "render"},
+            "image": renderer.render_document(document["render"]),
+        })
+    return {**inputs, "documents": converted}

sentence_bert_config.json

@@ -0,0 +1,30 @@
+{
+    "transformer_task": "any-to-any",
+    "modality_config": {
+        "text": {
+            "method": "forward",
+            "method_output_name": "logits"
+        },
+        "image": {
+            "method": "forward",
+            "method_output_name": "logits"
+        },
+        "video": {
+            "method": "forward",
+            "method_output_name": "logits"
+        },
+        "message": {
+            "method": "forward",
+            "method_output_name": "logits",
+            "format": "structured"
+        }
+    },
+    "module_output_name": "causal_logits",
+    "processing_kwargs": {
+        "chat_template": {
+            "chat_template": "reranker",
+            "add_generation_prompt": true
+        }
+    },
+    "unpad_inputs": false
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be75606093db2094d7cd20f3c2f385c212750648bd6ea4fb2bf507a6a4c55506
+size 11422650

tokenizer_config.json

@@ -0,0 +1,18 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "is_local": true,
+  "local_files_only": false,
+  "max_pixels": 802816,
+  "min_pixels": 4096,
+  "model_max_length": 262144,
+  "pad_token": "<|endoftext|>",
+  "processor_class": "Qwen3VLProcessor",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}