PaddleOCR

https://www.paddleocr.ai/main/main/
Admin
PaddleOCR is an advanced optical character recognition framework that supports text detection,...
Tokens:16,871
Snippets:152
Trust Score:5.9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Start llama.cpp Inference Server for PaddleOCR-VL

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Starts the llama.cpp HTTP server for PaddleOCR-VL using a GGUF model and mmproj file. Ensure llama.cpp is installed and model files are correctly path-ed.

```bash
./build/bin/llama-server \
  -m /path/to/PaddleOCR-VL-1.6-GGUF.gguf \
  --mmproj /path/to/PaddleOCR-VL-1.6-GGUF-mmproj.gguf  \
  --port 8111  \
  --host 0.0.0.0 \
  --temp 0
```

--------------------------------

### Start PaddleOCR-VL with Docker Compose

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Execute this command in the directory containing compose.yaml and .env files to start the PaddleOCR-VL services. Ensure you have the necessary NVIDIA drivers and CUDA versions installed.

```bash
docker compose up
```

--------------------------------

### Start PaddleOCR-VL GenAI Server

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Launches the PaddleOCR-VL GenAI server with specified model and backend. Ensure the backend (e.g., vLLM) is installed and compatible with the CUDA version.

```bash
paddleocr genai_server --model_name PaddleOCR-VL-1.6-0.9B --backend vllm --port 8118
```

--------------------------------

### Install PaddleX Serving Plugin

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Before manual deployment, install the serving plugin using the PaddleX CLI. This command is typically not needed if PaddleOCR was installed with its dependencies.

```bash
paddlex --install serving
```

--------------------------------

### Start vLLM Server with Configuration

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Launch the PaddleOCR genai server using a specified backend configuration file for vLLM.

```bash
paddleocr genai_server --model_name PaddleOCR-VL-1.6-0.9B --backend vllm --backend_config vllm_config.yaml
```

--------------------------------

### Start vLLM Server with Inline Configuration

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Start the PaddleOCR genai server with vLLM backend, passing configuration directly via process substitution.

```bash
paddleocr genai_server --model_name PaddleOCR-VL-1.6-0.9B --backend vllm --backend_config <(echo -e 'gpu-memory-utilization: 0.3
max-num-seqs: 128')
```

--------------------------------

### Install PaddleOCR and GenAI Server Dependencies

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Installs PaddleOCR and its dependencies for the GenAI server, using vLLM as an example. Ensure your environment meets the CUDA version requirements for the chosen backend.

```bash
python -m pip install "paddleocr[doc-parser]"
paddleocr install_genai_server_deps vllm
```

--------------------------------

### Start VLM Service with Docker (vLLM)

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Launches a VLM inference service using the official PaddleOCR Docker image with vLLM backend. Requires Docker version >= 19.03 and a compatible GPU setup.

```bash
docker run \
    -it \
    --rm \
    --gpus all \
    --network host \
    ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleocr-genai-vllm-server:latest-nvidia-gpu \
    paddleocr genai_server --model_name PaddleOCR-VL-1.6-0.9B --host 0.0.0.0 --port 8118 --backend vllm
```

--------------------------------

### Start PaddleOCR-VL Server with Transformers Engine

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

To use the 'transformers' engine instead of the default for PaddleOCR-VL, specify the engine using the '--engine' flag with the PaddleX CLI.

```bash
paddlex --serve --pipeline PaddleOCR-VL --engine transformers
```

--------------------------------

### Install PaddleOCR Base Packages

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Install the necessary base packages for PaddleOCR-VL, including the doc-parser extra. This command should be run after installing the inference engine.

```bash
python -m pip install -U "paddleocr[doc-parser]"

```

--------------------------------

### Install PaddlePaddle for x64 CPU

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Install PaddlePaddle CPU version 3.2.1. Ensure you do not install both CPU and GPU versions simultaneously.

```bash
# x64 CPU
python -m pip install paddlepaddle==3.2.1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/

```

--------------------------------

### PaddleOCR-VL C++ Client Setup

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

This C++ code snippet sets up the necessary includes and client for interacting with the PaddleOCR-VL service. It includes headers for HTTP client, JSON parsing, and Base64 encoding, and begins the file reading process for an image.

```C++
#include <iostream>
#include <filesystem>
#include <fstream>
#include <vector>
#include <string>
#include "cpp-httplib/httplib.h" // https://github.com/Huiyicc/cpp-httplib
#include "nlohmann/json.hpp" // https://github.com/nlohmann/json
#include "base64.hpp" // https://github.com/tobiaslocker/base64

namespace fs = std::filesystem;

int main() {
    httplib::Client client("localhost", 8080);

    const std::string filePath = "./demo.jpg";

    std::ifstream file(filePath, std::ios::binary | std::ios::ate);
    if (!file) {
        std::cerr << "Error opening file: " << filePath << std::endl;
        return 1;
    }

```

--------------------------------

### Start PaddleOCR-VL Server Manually

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Use the PaddleX CLI to start the PaddleOCR-VL server. The server will default to listening on port 8080.

```bash
paddlex --serve --pipeline PaddleOCR-VL
```

--------------------------------

### FastDeploy Server Configuration for RTX 3060

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Example server-side configurations for FastDeploy on an NVIDIA RTX 3060, including GPU memory utilization and max concurrency.

```yaml
gpu-memory-utilization: 0.7
max-concurrency: 2048
```

--------------------------------

### Python API Initialization with vLLM Server (Default Params)

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Initializes the PaddleOCRVL Python object, targeting a vLLM server started with default parameters. Specify the model name if it differs from the default.

```python
pipeline = PaddleOCRVL(
    vl_rec_backend="vllm-server",
    vl_rec_server_url="http://localhost:8000/v1",
    vl_rec_api_model_name="PaddlePaddle/PaddleOCR-VL-1.6",
)
```

--------------------------------

### Install PaddlePaddle for NVIDIA GPU

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Install PaddlePaddle GPU version 3.2.1 for CUDA 12.6. Ensure you do not install both CPU and GPU versions simultaneously. Refer to the PaddlePaddle installation guide for other CUDA versions.

```bash
# NVIDIA GPU（以 CUDA 12.6 为例）
python -m pip install paddlepaddle-gpu==3.2.1 -i https://www.paddlepaddle.org.cn/packages/stable/cu126/

```

--------------------------------

### Create and Activate Python Virtual Environment

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Steps to create and activate a Python virtual environment using venv. This is recommended to avoid dependency conflicts when installing PaddleOCR-VL.

```bash
# 创建虚拟环境
python -m venv .venv_paddleocr
# 激活环境
source .venv_paddleocr/bin/activate

```

--------------------------------

### Change VLM Inference Backend

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Modify the .env file to switch the VLM inference backend. This example changes the backend from 'vllm' to 'fastdeploy'.

```ini
  API_IMAGE_TAG_SUFFIX=latest-nvidia-gpu-offline
- VLM_BACKEND=vllm
+ VLM_BACKEND=fastdeploy
  VLM_IMAGE_TAG_SUFFIX=latest-nvidia-gpu-offline


```

--------------------------------

### Deploy PaddleOCR-VL with Docker Compose

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Command to start the PaddleOCR-VL server using Docker Compose, which defaults to listening on port 8080.

```bash
docker compose up -d
```

--------------------------------

### Pull Docker Images for PaddleOCR-VL

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Before starting the services, it's recommended to pull the latest Docker images. This ensures you are using the most up-to-date versions of the PaddleOCR-VL and VLM inference services.

```bash
docker compose pull
```

--------------------------------

### Switch to Transformers Engine in PaddleOCR-VL CLI

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

To utilize the `transformers` engine instead of the default Paddle engine, append `--engine transformers` to your command. This example shows how to do it for document parsing.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --engine transformers --save_path ./output
```

--------------------------------

### Run PaddleOCR-VL Docker Container (NVIDIA GPU)

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Use this command to start the official PaddleOCR-VL Docker container with GPU support. Ensure Docker version is >= 19.03 and your NVIDIA driver supports CUDA 12.6 or higher.

```bash
docker run \
    -it \
    --gpus all \
    --network host \
    --user root \
    ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleocr-vl:latest-nvidia-gpu \
    /bin/bash
# 在容器中调用 PaddleOCR CLI 或 Python API

```

--------------------------------

### Configure GPU for PaddleOCR-VL Services

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Specify which GPU to use for the PaddleOCR-VL API and VLM server by editing the 'device_ids' in the compose.yaml file. This example assigns GPU 1.

```yaml
  paddleocr-vl-api:
    ...
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
-             device_ids: ["0"]
+             device_ids: ["1"]
              capabilities: [gpu]
    ...
  paddleocr-vlm-server:
    ...
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
-             device_ids: ["0"]
+             device_ids: ["1"]
              capabilities: [gpu]
    ...
```

--------------------------------

### CLI Call to PaddleOCR Doc Parser with vLLM Server (Default Params)

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Invokes the PaddleOCR document parser via CLI, targeting a vLLM server started with default parameters. Specify the model name if it differs from the default.

```bash
paddleocr doc_parser \
    --input https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png \
    --vl_rec_backend vllm-server \
    --vl_rec_server_url http://localhost:8000/v1 \
    --vl_rec_api_model_name 'PaddlePaddle/PaddleOCR-VL-1.6'
```

--------------------------------

### Layout Parsing and Restructuring with PaddleOCR-VL

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

This section covers the usage of the PaddleOCR-VL API for layout parsing and restructuring documents. It includes details on request parameters, response structures, and provides comprehensive code examples.

```APIDOC
## POST /layout-parsing

### Description
Parses the layout of an input image or document.

### Method
POST

### Endpoint
/layout-parsing

### Parameters
#### Request Body
- **file** (string) - Required - Base64 encoded file content or file URL.
- **fileType** (integer) - Required - File type, 1 for image files.
- **visualize** (boolean) - Optional - Overrides default behavior to return images. If not set in request body or config, defaults to returning images.

### Response
#### Success Response (200)
- **result** (object) - The result of the layout parsing.
  - **layoutParsingResults** (array) - Layout parsing results. Array length is 1 for image input or the number of pages for PDF input.
    - Each element is an object with:
      - **prunedResult** (object) - Simplified JSON representation of the prediction result, excluding `input_path` and `page_index`.
      - **markdown** (object) - Markdown representation of the parsed content.
        - **text** (string) - Markdown text.
        - **images** (object | null) - Key-value pairs of relative image paths and corresponding images. Images are Base64 encoded by default or pre-signed URLs when URL return mode is enabled. This field is null or absent if `returnMarkdownImages` is false.
      - **outputImages** (object | null) - Output images in JPEG format. Base64 encoded by default or pre-signed URLs. Null if not generated.
      - **inputImage** (string | null) - Input image. Base64 encoded by default or pre-signed URL. Null if not returned.
      - **exports** (object | null) - Optional additional export results (e.g., "docx"). Base64 encoded content or pre-signed URLs. Only present if `outputFormats` is specified in the request.
  - **dataInfo** (object) - Input data information.

### Request Example
```json
{
  "file": "<base64_encoded_image_data>",
  "fileType": 1,
  "visualize": true
}
```

### Response Example
```json
{
  "result": {
    "layoutParsingResults": [
      {
        "prunedResult": { ... },
        "markdown": {
          "text": "# Document Title\n...",
          "images": {
            "image1.png": "<base64_encoded_image_data>"
          }
        },
        "outputImages": {
          "output_image.jpg": "<base64_encoded_image_data>"
        },
        "inputImage": "<base64_encoded_image_data>",
        "exports": {
          "docx": {
            "content": "<base64_encoded_docx_content>"
          }
        }
      }
    ],
    "dataInfo": { ... }
  }
}
```

## POST /restructure-pages

### Description
Restructures multi-page results from layout parsing.

### Method
POST

### Endpoint
/restructure-pages

### Parameters
#### Request Body
- **pages** (array) - Required - Array of page objects.
  - Each page object contains:
    - **prunedResult** (object) - The `prunedResult` object from the `infer` operation.
    - **markdownImages** (object | null) - The `images` property from the `markdown` object of the `infer` operation.
- **mergeTables** (boolean) - Optional - Whether to merge tables. See PaddleOCR-VL object `restructure_pages` method documentation.
- **relevelTitles** (boolean) - Optional - Whether to relevel titles. See PaddleOCR-VL object `restructure_pages` method documentation.
- **concatenatePages** (boolean) - Optional - Whether to concatenate pages.
- **prettifyMarkdown** (boolean) - Optional - Whether to output prettified Markdown text. Defaults to `true`.
- **showFormulaNumber** (boolean) - Optional - Whether to include formula numbers in the output Markdown. Defaults to `false`.
- **returnMarkdownImages** (boolean) - Optional - Whether to return images referenced in Markdown. Defaults to `true`. If `false`, `markdown.images` will be null or absent, and image encoding/upload is skipped.
- **outputFormats** (array) - Optional - Additional export formats. Currently supports `"docx"`.

### Response
#### Success Response (200)
- **result** (object) - The restructured layout parsing results.
  - **layoutParsingResults** (array) - Restructured layout parsing results. Each element contains fields similar to the `infer` operation's response (excluding visualization and intermediate images).

### Request Example
```json
{
  "pages": [
    {
      "prunedResult": { ... },
      "markdownImages": {
        "image1.png": "<base64_encoded_image_data>"
      }
    }
  ],
  "concatenatePages": true,
  "prettifyMarkdown": true
}
```

### Response Example
```json
{
  "result": {
    "layoutParsingResults": [
      {
        "prunedResult": { ... },
        "markdown": {
          "text": "# Restructured Document\n...",
          "images": {
            "image1.png": "<base64_encoded_image_data>"
          }
        }
      }
    ]
  }
}
```
```

--------------------------------

### Run PaddleOCR-VL Server with FastDeploy

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Launches the PaddleOCR-VL server using the FastDeploy backend. Ensure you have internet access for the specified image. For offline use, replace the image tag with the '-offline' version.

```bash
docker run \
    -it \
    --rm \
    --gpus all \
    --network host \
    ccr-2vdh3abhv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleocr-genai-fastdeploy-server:latest-nvidia-gpu \
    paddleocr genai_server --model_name PaddleOCR-VL-1.6-0.9B --host 0.0.0.0 --port 8118 --backend fastdeploy
```

--------------------------------

### Initialize PaddleOCR-VL with Novita AI

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Initialize PaddleOCR-VL using the v1 pipeline version with vLLM backend pointing to the Novita AI platform.

```python
pipeline = PaddleOCRVL(
    pipeline_version="v1",
    vl_rec_backend="vllm-server", 
    vl_rec_server_url="https://api.novita.ai/openai",
    vl_rec_api_model_name="paddlepaddle/paddleocr-vl",
    vl_rec_api_key="xxxxxx",
)
```

--------------------------------

### Run PaddleOCR-VL with Kunlunxin XPU

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Execute this command to use PaddleOCR-VL on Kunlunxin XPU hardware. Ensure the `--device xpu` flag is set. Results can be saved using `--save_path`.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --device xpu --save_path ./output
```

--------------------------------

### Configure PaddleOCR-VL API Port

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Modify the compose.yaml file to change the port exposed by the PaddleOCR-VL API service. This example changes the port from 8080 to 8111.

```yaml
  paddleocr-vl-api:
    ...
    ports:
-     - 8080:8080
+     - 8111:8080
    ...
```

--------------------------------

### Run PaddleOCR-VL on Apple Silicon (CPU)

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

This command runs PaddleOCR-VL on Apple Silicon using the CPU. The `--device cpu` flag is used. It's recommended to use `--save_path ./output` to store results.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --device cpu --save_path ./output
```

--------------------------------

### Python API Initialization with vLLM Server

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Initializes the PaddleOCRVL Python object, specifying the vLLM server backend and URL. Ensure the server is running and accessible.

```python
pipeline = PaddleOCRVL(vl_rec_backend="vllm-server", vl_rec_server_url="http://localhost:8118/v1")
```

--------------------------------

### Run PaddleOCR-VL Server with vLLM and Custom Configuration

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Deploys the PaddleOCR-VL server using the vLLM backend with a custom configuration file. Mount your local configuration file (e.g., vllm_config.yml) into the container and specify its path using the --backend_config argument. This allows for fine-tuning parameters like GPU memory usage.

```bash
docker run \
    -it \
    --rm \
    --gpus all \
    --network host \
    -v ./vllm_config.yml:/tmp/vllm_config.yml \
    ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleocr-genai-vllm-server:latest-nvidia-gpu \
    paddleocr genai_server --model_name PaddleOCR-VL-1.6-0.9B --host 0.0.0.0 --port 8118 --backend vllm --backend_config /tmp/vllm_config.yml
```

--------------------------------

### Run PaddleOCR-VL with Muxi GPU

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Use this command to leverage Muxi GPU for PaddleOCR-VL processing. Set the device using `--device metax_gpu`. Saving results locally is possible with `--save_path`.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --device metax_gpu --save_path ./output
```

--------------------------------

### Run PaddleOCR-VL with NVIDIA GPU

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Use this command for quick verification on NVIDIA GPUs. It automatically downloads models on the first run. Consider adding `--save_path ./output` to view results.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --save_path ./output
```

--------------------------------

### Initialize PaddleOCR-VL with Transformers Engine

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Integrate PaddleOCR-VL using the 'transformers' engine. This is an alternative to the default engine for inference.

```python
from pathlib import Path

from paddleocr import PaddleOCRVL

output_dir = Path("./output")
output_dir.mkdir(parents=True, exist_ok=True)

pipeline = PaddleOCRVL(engine="transformers")
output = pipeline.predict("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png")
for res in output:
    res.print() ## 打印预测的结构化输出
    res.save_to_json(save_path=output_dir) ## 保存当前图像的结构化json结果
    res.save_to_markdown(save_path=output_dir) ## 保存当前图像的markdown格式的结果
    res.save_to_word(save_path=output_dir) ## 保存当前图像的Word格式的结果
```

--------------------------------

### Initialize PaddleOCR-VL with Default Settings

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Instantiate PaddleOCR-VL for inference. Supports various hardware devices like NVIDIA GPU, XPU, DCU, Metax GPU, and CPU. For Huawei Ascend NPU, refer to Chapter 3.

```python
from pathlib import Path

from paddleocr import PaddleOCRVL

output_dir = Path("./output")
output_dir.mkdir(parents=True, exist_ok=True)

# NVIDIA GPU
pipeline = PaddleOCRVL()
# 昆仑芯 XPU
# pipeline = PaddleOCRVL(device="xpu")
# 海光 DCU
# pipeline = PaddleOCRVL(device="dcu")
# 沐曦 GPU
# pipeline = PaddleOCRVL(device="metax_gpu")
# Apple Silicon
# pipeline = PaddleOCRVL(device="cpu")
# 华为昇腾 NPU 
# 华为昇腾 NPU 请参考第 3 章节使用 PaddlePaddle + vLLM 的方式进行推理

# pipeline = PaddleOCRVL(use_doc_orientation_classify=True) # 通过 use_doc_orientation_classify 指定是否使用文档方向分类模型
# pipeline = PaddleOCRVL(use_doc_unwarping=True) # 通过 use_doc_unwarping 指定是否使用文本图像矫正模块
# pipeline = PaddleOCRVL(use_layout_detection=False) # 通过 use_layout_detection 指定是否使用版面分析模块

output = pipeline.predict("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png")
for res in output:
    res.print() ## 打印预测的结构化输出
    res.save_to_json(save_path=output_dir) ## 保存当前图像的结构化json结果
    res.save_to_markdown(save_path=output_dir) ## 保存当前图像的markdown格式的结果
    res.save_to_word(save_path=output_dir) ## 保存当前图像的Word格式的结果
```

--------------------------------

### Python API Initialization with SiliconFlow Platform

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Initializes the PaddleOCRVL Python object for the SiliconFlow platform. Requires specifying pipeline version, backend, server URL, model name, and API key.

```python
pipeline = PaddleOCRVL(
    pipeline_version="v1.5",
    vl_rec_backend="vllm-server", 
    vl_rec_server_url="https://api.siliconflow.cn/v1",
    vl_rec_api_model_name="PaddlePaddle/PaddleOCR-VL-1.5",
    vl_rec_api_key="xxxxxx",
)
```

--------------------------------

### PaddleOCR-VL Service Deployment Arguments

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Command-line arguments for deploying the PaddleOCR-VL service.

```APIDOC
## PaddleOCR-VL Service Deployment

### Description
Command-line arguments for deploying the PaddleOCR-VL service.

### Arguments

- `--pipeline` (string): PaddleX pipeline registration name or pipeline configuration file path.
- `--device` (string): Deployment device for the pipeline. Defaults to GPU if available, otherwise CPU.
- `--host` (string): Hostname or IP address the server binds to. Defaults to `0.0.0.0`.
- `--port` (integer): Port number the server listens on. Defaults to `8080`.
- `--use_hpip` (boolean): Enable high-performance inference mode. Refer to the high-performance inference documentation for more information.
- `--hpi_config` (string): High-performance inference configuration. Refer to the high-performance inference documentation for more information.

Refer to section 4.4 for adjusting pipeline-related configurations such as model paths, batch sizes, and deployment devices.
```

--------------------------------

### Run PaddleOCR-VL with Haiguang DCU

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

This command is for running PaddleOCR-VL on Haiguang DCU. Specify the device with `--device dcu`. The `--save_path` option is recommended for saving output.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --device dcu --save_path ./output
```

--------------------------------

### vLLM Server Configuration

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Create a YAML configuration file to adjust vLLM server parameters like GPU memory utilization and maximum sequences.

```yaml
gpu-memory-utilization: 0.3
max-num-seqs: 128
```

--------------------------------

### CLI Call to PaddleOCR Doc Parser with Novita AI Platform

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Invokes the PaddleOCR document parser via CLI, connecting to the Novita AI platform. Requires specifying pipeline version, backend, server URL, model name, and API key.

```bash
paddleocr doc_parser \
    --input https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png \
    --pipeline_version v1 \
    --vl_rec_backend vllm-server \
    --vl_rec_server_url https://api.novita.ai/openai \
    --vl_rec_api_model_name 'paddlepaddle/paddleocr-vl' \
    --vl_rec_api_key xxxxxx
```

--------------------------------

### Efficient Multi-File Prediction with PaddleOCR-VL

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

For processing multiple files, pass a directory path or a list of file paths to the `predict` method for maximum efficiency. This is faster than processing files individually in a loop.

```python
# `imgs` 目录中包含多张待处理图像：file1.png、file2.png、file3.png
# 传入目录路径
output = pipeline.predict("imgs")
# 或者传入文件路径列表
output = pipeline.predict(["imgs/file1.png", "imgs/file2.png", "imgs/file3.png"])
# 以上两种方式的处理效率高于下列方式：
# for file in ["imgs/file1.png", "imgs/file2.png", "imgs/file3.png"]:
#     output = pipeline.predict(file)
```

--------------------------------

### Layout Parsing and Page Restructuring with PaddleOCR-VL (Python)

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

This Python script demonstrates how to perform layout parsing on an image and then restructure the results. It handles Base64 encoding of images, sends requests to the `/layout-parsing` and `/restructure-pages` endpoints, and saves output images and Markdown documents.

```Python
import base64
import requests
import pathlib

BASE_URL = "http://localhost:8080"

image_path = "./demo.jpg"

# 对本地图像进行Base64编码
with open(image_path, "rb") as file:
    image_bytes = file.read()
    image_data = base64.b64encode(image_bytes).decode("ascii")

payload = {
    "file": image_data, # Base64编码的文件内容或者文件URL
    "fileType": 1, # 文件类型，1表示图像文件
}

response = requests.post(BASE_URL + "/layout-parsing", json=payload)
assert response.status_code == 200, (response.status_code, response.text)

result = response.json()["result"]
pages = []
for i, res in enumerate(result["layoutParsingResults"]):
    pages.append({"prunedResult": res["prunedResult"], "markdownImages": res["markdown"].get("images")})
    for img_name, img in res["outputImages"].items():
        img_path = f"{img_name}_{i}.jpg"
        pathlib.Path(img_path).parent.mkdir(exist_ok=True)
        with open(img_path, "wb") as f:
            f.write(base64.b64decode(img))
        print(f"Output image saved at {img_path}")

payload = {
    "pages": pages,
    "concatenatePages": True,
}

response = requests.post(BASE_URL + "/restructure-pages", json=payload)
assert response.status_code == 200, (response.status_code, response.text)

result = response.json()["result"]
res = result["layoutParsingResults"][0]
print(res["prunedResult"])
md_dir = pathlib.Path("markdown")
md_dir.mkdir(exist_ok=True)
(md_dir / "doc.md").write_text(res["markdown"]["text"])
for img_path, img in res["markdown"]["images"].items():
    img_path = md_dir / img_path
    img_path.parent.mkdir(parents=True, exist_ok=True)
    img_path.write_bytes(base64.b64decode(img))
print(f"Markdown document saved at {md_dir / 'doc.md'}")

```

--------------------------------

### Run PaddleOCR-VL with Document Unwarping

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Activate the text image unwarping module by including `--use_doc_unwarping True`. This is useful for correcting distorted text images. Use `--save_path` to save the processed results.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --use_doc_unwarping True --save_path ./output
```

--------------------------------

### CLI Call to PaddleOCR Doc Parser with SiliconFlow Platform

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Invokes the PaddleOCR document parser via CLI, connecting to the SiliconFlow platform. Requires specifying pipeline version, backend, server URL, model name, and API key.

```bash
paddleocr doc_parser \
    --input https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png \
    --pipeline_version v1.5 \
    --vl_rec_backend vllm-server \
    --vl_rec_server_url https://api.siliconflow.cn/v1 \
    --vl_rec_api_model_name 'PaddlePaddle/PaddleOCR-VL-1.5' \
    --vl_rec_api_key xxxxxx
```

--------------------------------

### Run PaddleOCR-VL with Document Orientation Classification

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Enable the document orientation classification model by adding the `--use_doc_orientation_classify True` flag. This helps in processing documents with varying orientations. Results can be saved using `--save_path`.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --use_doc_orientation_classify True --save_path ./output
```

--------------------------------

### CLI Call to PaddleOCR Doc Parser with vLLM Server

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

Invokes the PaddleOCR document parser via CLI, specifying the vLLM server backend and URL. Ensure the server is running and accessible.

```bash
paddleocr doc_parser --input https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --vl_rec_backend vllm-server --vl_rec_server_url http://localhost:8118/v1
```

--------------------------------

### Configure VLM Server with Custom Configuration File

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

To adjust VLM server settings, mount a custom configuration file into the VLM server container and specify it in the 'command' field of compose.yaml. Replace '/path/to/your_config.yaml' with the actual path to your configuration file.

```yaml
  paddleocr-vlm-server:
    ...
    volumes:
      - /path/to/your_config.yaml:/home/paddleocr/vlm_server_config.yaml
    command: paddleocr genai_server --model_name PaddleOCR-VL-1.6-0.9B --host 0.0.0.0 --port 8118 --backend vllm --backend_config /home/paddleocr/vlm_server_config.yaml
    ...
```

--------------------------------

### Run PaddleOCR-VL without Layout Detection

Source: https://www.paddleocr.ai/main/version3.x/pipeline_usage/PaddleOCR-VL.html

To disable the layout detection module, use the `--use_layout_detection False` flag. This can be useful for specific use cases where layout analysis is not required. Results can be saved with `--save_path`.

```bash
paddleocr doc_parser -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/paddleocr_vl_demo.png --use_layout_detection False --save_path ./output
```
Tokens:
Raw