Instructions to use PaddlePaddle/HPD-Parsing with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use PaddlePaddle/HPD-Parsing with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="PaddlePaddle/HPD-Parsing", trust_remote_code=True)
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("PaddlePaddle/HPD-Parsing", trust_remote_code=True, device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use PaddlePaddle/HPD-Parsing with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "PaddlePaddle/HPD-Parsing"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "PaddlePaddle/HPD-Parsing",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/PaddlePaddle/HPD-Parsing

SGLang

How to use PaddlePaddle/HPD-Parsing with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "PaddlePaddle/HPD-Parsing" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "PaddlePaddle/HPD-Parsing",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "PaddlePaddle/HPD-Parsing" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "PaddlePaddle/HPD-Parsing",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use PaddlePaddle/HPD-Parsing with Docker Model Runner:
```
docker model run hf.co/PaddlePaddle/HPD-Parsing
```

WEISHU commited on 4 days ago

Commit

ee704a3

verified ·

1 Parent(s): a3020fd

Upload README.md with huggingface_hub

Browse files

Files changed (1) hide show

README.md +14 -16

README.md CHANGED Viewed

@@ -44,6 +44,7 @@ HPD-Parsing: Hierarchical Parallel Document Parsing
 ## News
 * ```2026.07``` 🚀 We release **HPD-Parsing**, a 1B hierarchical parallel document parser. It achieves 94.91% overall on OmniDocBench v1.6 and 4,752 TPS peak throughput.
@@ -83,27 +84,24 @@ HPD-Parsing adopts **InternVL3.5-1B** as its backbone, applies dynamic tile-base
 HPD-Parsing runs on a **customized build of vLLM** (based on vLLM v0.17.1) that implements the dynamic request forking required by hierarchical parallel decoding and adapts P-MTP speculative decoding.
-### 1. Prepare the Runtime Environment
-Either option works; **the Docker image is strongly recommended** to minimize environment issues.
-**Option A — Docker image** (ships the customized vLLM build and all dependencies):
-```text
-ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm:latest-nvidia-gpu
-```
-The default entrypoint starts the inference server automatically (see Serving below). It is pulled automatically on the first `docker run`. For machines without internet access, use the offline image `...:latest-nvidia-gpu-offline` (~24.5 GB; it has the model weights built in). Pull it on a networked machine and transfer it:
 ```shell
-# On a machine with internet access
-docker pull ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm:latest-nvidia-gpu-offline
-docker save ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm:latest-nvidia-gpu-offline -o hpd-parsing-vllm-offline.tar
-# Transfer the tar to the offline machine, then:
-docker load -i hpd-parsing-vllm-offline.tar
 ```
-**Option B — Prebuilt package** (Python 3.10–3.13, NVIDIA driver with CUDA 12.8+). Install in a virtual environment to avoid dependency conflicts:
 ```shell
 python -m venv .venv_hpd_parsing
@@ -111,7 +109,7 @@ source .venv_hpd_parsing/bin/activate
 python -m pip install https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpd_parsing/vllm-0.17.1+hpdparsing-cp38-abi3-manylinux_2_31_x86_64.whl
 ```
-### 2. vLLM Python API
 ```python
 # Set the environment variable before running: export MAX_PATCHES_WITH_RESIZE=true

 ## News
+* ```2026.07``` 🎉 A live demo is available at [hugging-apps/hpd-parsing](https://huggingface.co/spaces/hugging-apps/hpd-parsing). Thanks to [multimodalart](https://huggingface.co/multimodalart) for building it!
 * ```2026.07``` 🚀 We release **HPD-Parsing**, a 1B hierarchical parallel document parser. It achieves 94.91% overall on OmniDocBench v1.6 and 4,752 TPS peak throughput.
 HPD-Parsing runs on a **customized build of vLLM** (based on vLLM v0.17.1) that implements the dynamic request forking required by hierarchical parallel decoding and adapts P-MTP speculative decoding.
+### 1. Using Docker
+The Docker image ships the customized vLLM build and all dependencies, which is the easiest way to get started. Its default entrypoint runs the Python API example below out of the box.
+**With the online Docker image**, start the container directly. It downloads the model and starts the inference server, which listens on port **8118** by default:
 ```shell
+docker run \
+    -it \
+    --rm \
+    --gpus all \
+    --network host \
+    ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm:latest-nvidia-gpu
 ```
+### 2. vLLM Python API
+Without Docker, install the customized vLLM prebuilt package (Python 3.10–3.13, NVIDIA driver with CUDA 12.8+) in a virtual environment to avoid dependency conflicts:
 ```shell
 python -m venv .venv_hpd_parsing
 python -m pip install https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpd_parsing/vllm-0.17.1+hpdparsing-cp38-abi3-manylinux_2_31_x86_64.whl
 ```
+Then run inference with the vLLM Python API:
 ```python
 # Set the environment variable before running: export MAX_PATCHES_WITH_RESIZE=true