POINTS-Reader: Distillation-Free Adaptation of Vision-Language Models for Document Conversion

We are delighted to announce that the WePOINTS family has welcomed a new member: POINTS-Reader, a vision-language model for end-to-end document conversion.

News

2025.08.27: Support deploying POINTS-Reader with SGLang💪💪💪.
2025.08.26: We released the weights of the most recent version of POINT-Reader🔥🔥🔥.
2025.08.21: POINTS-Reader is accepted by EMNLP 2025 for presentation at the Main Conference🎉🎉🎉.

Introduction

Simplicity: POINTS-Reader is a very streamlined model that fully follows the structure of POINTS1.5, except that we have replaced Qwen2.5-7B-Instruct with Qwen2.5-3B-Instruct. Moreover, the input and output of POINTS-Reader are extremely straightforward. The input consists of a fixed prompt and a document image, and the output contains only a string (text extracted from the document image). The model's output is the final result delivered to the user without any post-processing.
Performance: Currently, POINTS-Reader supports extraction from both Chinese and English documents, achieving impressive results, with scores of 0.133 for English and 0.212 for Chinese on OmniDocBench.
High Throughput: With current mainstream inference frameworks, such as SGLang and vLLM, optimization is predominantly focused on LLMs. Thus, a large ViT would significantly impact the model’s throughput, which is why we selected a ViT with a moderate number of parameters (600M NaViT used in POINTS1.5). Combined with our support for SGLang, we currently achieve a very satisfactory throughput. We will also provide support for vLLM in the future.
Open-source Technical Approach: In the POINTS-Reader paper, we propose a two-stage data augmentation strategy. The first stage leverages automated data to endow the model with basic document extraction capabilities. In the subsequent stage, continuous self-evolution improves the quality of data generated by the model. The self-evolution approach in the second stage is highly extensible and can be applied to virtually any model.

Results

For comparison, we use the results reported by OmniDocBench and POINTS-Reader. Compared with the version submitted to EMNLP 2025, the current release provides (1) improved performance and (2) support for Chinese documents. Both enhancements build upon the methods proposed in this paper.

Method Type	Methods	Overall^Edit↓		Text^Edit↓		Formula^Edit↓		Formula^CDM↑		Table^TEDS↑		Table^Edit↓		Read Order^Edit↓
Method Type	Methods	EN	ZH	EN	ZH	EN	ZH	EN	ZH	EN	ZH	EN	ZH	EN	ZH
Pipeline Tools	MinerU-pipeline-2.1.1	0.162	0.244	0.072	0.111	0.313	0.581	79.2	48.8	77.4	79.5	0.166	0.15	0.097	0.136
	Marker-1.2.3	0.336	0.556	0.08	0.315	0.53	0.883	17.6	11.7	67.6	49.2	0.619	0.685	0.114	0.34
	Marker-1.7.1	0.296	0.497	0.085	0.293	0.374	0.688	79.0	36.7	67.6	54.0	0.609	0.678	0.116	0.329
	PaddleOCR PP-StructureV3	0.145	0.206	0.058	0.088	0.295	0.535	81.8	52.1	77.2	83.9	0.159	0.109	0.069	0.091
	Mathpix	0.191	0.364	0.105	0.381	0.306	0.454	82.7	64.6	77.0	67.1	0.243	0.32	0.108	0.304
	Docling-2.14.0	0.589	0.909	0.416	0.987	0.999	1	-	-	61.3	25.0	0.627	0.810	0.313	0.837
	Pix2Text-1.1.2.3	0.32	0.528	0.138	0.356	0.276	0.611	78.4	39.6	73.6	66.2	0.584	0.645	0.281	0.499
	Unstructured-0.17.2	0.586	0.716	0.198	0.481	0.999	1	-	-	0	0.064	1	0.998	0.145	0.387
	OpenParse-0.7.0	0.646	0.814	0.681	0.974	0.996	1	0.106	0	64.8	27.5	0.284	0.639	0.595	0.641
Expert VLMs	POINTS-Reader-3B	0.133	0.212	0.062	0.139	0.304	0.465	-	-	83.7	85.0	0.128	0.136	0.036	0.106
	MinerU2.0-2505-0.9B	0.133	0.238	0.045	0.115	0.273	0.506	79.0	50.8	82.1	83.4	0.15	0.209	0.066	0.122
	MonkeyOCR-pro-1.2B	0.146	0.221	0.068	0.118	0.272	0.452	76.7	63.3	81.3	85.5	0.149	0.134	0.093	0.179
	Dolphin	0.356	0.440	0.352	0.440	0.465	0.604	61.6	40.4	70.2	56.8	0.258	0.367	0.35	0.351
	Nanonets-OCR-s	0.283	0.295	0.134	0.231	0.518	0.546	63.2	52.0	76.8	79.4	0.343	0.201	0.135	0.2
	OCRFlux-3B	0.238	0.349	0.112	0.256	0.447	0.716	60.2	31.9	69.0	80.0	0.269	0.162	0.126	0.263
	GOT-OCR	0.287	0.411	0.189	0.315	0.360	0.528	74.3	45.3	53.2	47.2	0.459	0.52	0.141	0.28
	Nougat	0.452	0.973	0.365	0.998	0.488	0.941	15.1	16.8	39.9	0.0	0.572	1.000	0.382	0.954
	Mistral OCR	0.268	0.439	0.072	0.325	0.318	0.495	64.6	45.9	75.8	63.6	0.6	0.65	0.083	0.284
	OLMOCR-sglang	0.326	0.469	0.097	0.293	0.455	0.655	74.3	43.2	68.1	61.3	0.608	0.652	0.145	0.277
	SmolDocling-256M_transformer	0.493	0.816	0.262	0.838	0.753	0.997	32.1	0.551	44.9	16.5	0.729	0.907	0.227	0.522
General VLMs
	Gemini2.0-flash	0.191	0.264	0.091	0.139	0.389	0.584	77.6	43.6	79.7	78.9	0.193	0.206	0.092	0.128
	Gemini2.5-Pro	0.148	0.212	0.055	0.168	0.356	0.439	80.0	69.4	85.8	86.4	0.13	0.119	0.049	0.121
	GPT4o	0.233	0.399	0.144	0.409	0.425	0.606	72.8	42.8	72.0	62.9	0.234	0.329	0.128	0.251
	Qwen2-VL-72B	0.252	0.327	0.096	0.218	0.404	0.487	82.2	61.2	76.8	76.4	0.387	0.408	0.119	0.193
	Qwen2.5-VL-7B	0.316	0.399	0.151	0.243	0.376	0.5	75.3	57.3	71.1	71.3	0.598	0.627	0.138	0.226
	Qwen2.5-VL-72B	0.214	0.261	0.092	0.18	0.315	0.434	81.4	64.1	81.4	83.0	0.341	0.262	0.106	0.168
	InternVL2-76B	0.44	0.443	0.353	0.290	0.543	0.701	67.4	44.1	63.0	60.2	0.547	0.555	0.317	0.228
	InternVL3-78B	0.218	0.296	0.117	0.21	0.38	0.533	79.2	58.8	69.0	73.9	0.279	0.282	0.095	0.161

Getting Started

This following code snippet has been tested with following environment:

python==3.10.12
torch==2.5.1
transformers==4.55.2
cuda==12.1

If you encounter environment issues, please feel free to open an issue.

Run with Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer, Qwen2VLImageProcessor
import torch


# We recommend using the following prompt to better performance,
# since it is used throughout the training process.
prompt = (
    'Please extract all the text from the image with the following requirements:\n'
    '1. Return tables in HTML format.\n'
    '2. Return all other text in Markdown format.'
)
image_path = '/path/to/your/local/image'
model_path = 'tencent/POINTS-Reader'
model = AutoModelForCausalLM.from_pretrained(model_path,
                                             trust_remote_code=True,
                                             torch_dtype=torch.float16,
                                             device_map='cuda')
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
image_processor = Qwen2VLImageProcessor.from_pretrained(model_path)
content = [
            dict(type='image', image=image_path),
            dict(type='text', text=prompt)
          ]
messages = [
        {
            'role': 'user',
            'content': content
        }
    ]
generation_config = {
        'max_new_tokens': 2048,
        'repetition_penalty': 1.05,
        'temperature': 0.7,
        'top_p': 0.8,
        'top_k': 20,
        'do_sample': True
    }
response = model.chat(
    messages,
    tokenizer,
    image_processor,
    generation_config
)
print(response)

If you encounter issues like repeation, please try to increase the resolution of the image to allievate the problem.

Deploy with SGLang

We have created a Pull Request for SGLang. You can check out this branch and install SGLang in editable mode by following the official guide prior to the merging of this PR.

How to Deploy

You can deploy POINTS-Reader with SGLang using the following command:

python3 -m sglang.launch_server \
--model-path tencent/POINTS-Reader \
--tp-size 1 \
--dp-size 1 \
--chat-template points-v15-chat \
--trust-remote-code \
--port 8081

How to Use

You can use the following code to obtain results from SGLang:


from typing import List
import requests
import json



def call_wepoints(messages: List[dict],
                 temperature: float = 0.0,
                 max_new_tokens: int = 2048,
                 repetition_penalty: float = 1.05,
                 top_p: float = 0.8,
                 top_k: int = 20,
                 do_sample: bool = True,
                 url: str = 'http://127.0.0.1:8081/v1/chat/completions') -> str:
    """Query WePOINTS model to generate a response.

    Args:
        messages (List[dict]): A list of messages to be sent to WePOINTS. The
            messages should be the standard OpenAI messages, like:
            [
                {
                    'role': 'user',
                    'content': [
                        {
                            'type': 'text',
                            'text': 'Please describe this image in short'
                        },
                        {
                            'type': 'image_url',
                            'image_url': {'url': /path/to/image.jpg}
                        }
                    ]
                }
            ]
        temperature (float, optional): The temperature of the model.
            Defaults to 0.0.
        max_new_tokens (int, optional): The maximum number of new tokens to generate.
            Defaults to 2048.
        repetition_penalty (float, optional): The penalty for repetition.
            Defaults to 1.05.
        top_p (float, optional): The top-p probability threshold.
            Defaults to 0.8.
        top_k (int, optional): The top-k sampling vocabulary size.
            Defaults to 20.
        do_sample (bool, optional): Whether to use sampling or greedy decoding.
            Defaults to True.
        url (str, optional): The URL of the WePOINTS model.
            Defaults to 'http://127.0.0.1:8081/v1/chat/completions'.

    Returns:
        str: The generated response from WePOINTS.
    """
    data = {
        'model': 'WePoints',
        'messages': messages,
        'max_new_tokens': max_new_tokens,
        'temperature': temperature,
        'repetition_penalty': repetition_penalty,
        'top_p': top_p,
        'top_k': top_k,
        'do_sample': do_sample,
    }
    response = requests.post(url,
                             json=data)
    response = json.loads(response.text)
    response = response['choices'][0]['message']['content']
    return response

prompt = (
    'Please extract all the text from the image with the following requirements:\n'
    '1. Return tables in HTML format.\n'
    '2. Return all other text in Markdown format.'
)

messages = [{
              'role': 'user',
              'content': [
                  {
                      'type': 'text',
                      'text': prompt
                  },
                  {
                      'type': 'image_url',
                      'image_url': {'url': '/path/to/image.jpg'}
                  }
              ]
            }]
response = call_wepoints(messages)
print(response)

Known Issues

Complex Document Parsing: POINTS-Reader can struggle with complex layouts (e.g., newspapers), often producing repeated or missing content.
Handwritten Document Parsing: It also has difficulty handling handwritten inputs (e.g., receipts, notes), which can lead to recognition errors or omissions.
Multi-language Document Parsing: POINTS-Reader currently supports only English and Chinese, limiting its effectiveness on other languages.

Citation

If you use this model in your work, please cite the following paper:

@article{points-reader,
  title={POINTS-Reader: Distillation-Free Adaptation of Vision-Language Models for Document Conversion},
  author={Liu, Yuan and Zhongyin Zhao and Tian, Le and Haicheng Wang and Xubing Ye and Yangxiu You and Zilin Yu and Chuhan Wu and  Zhou, Xiao and Yu, Yang and Zhou, Jie},
  journal={EMNLP2025},
  year={2025}
}

@article{liu2024points1,
  title={POINTS1. 5: Building a Vision-Language Model towards Real World Applications},
  author={Liu, Yuan and Tian, Le and Zhou, Xiao and Gao, Xinyu and Yu, Kavio and Yu, Yang and Zhou, Jie},
  journal={arXiv preprint arXiv:2412.08443},
  year={2024}
}

@article{liu2024points,
  title={POINTS: Improving Your Vision-language Model with Affordable Strategies},
  author={Liu, Yuan and Zhao, Zhongyin and Zhuang, Ziyuan and Tian, Le and Zhou, Xiao and Zhou, Jie},
  journal={arXiv preprint arXiv:2409.04828},
  year={2024}
}

@article{liu2024rethinking,
  title={Rethinking Overlooked Aspects in Vision-Language Models},
  author={Liu, Yuan and Tian, Le and Zhou, Xiao and Zhou, Jie},
  journal={arXiv preprint arXiv:2405.11850},
  year={2024}
}