MinerU 性能优化

# 模型源配置
export MINERU_MODEL_SOURCE=local
export MINERU_MODEL_DIR=/root/.cache/mineru_models

# NPU配置
export HCCL_OP_EXPANSION_MODE=AIV
export MINERU_DEVICE_MODE=npu

# 性能参数
export MINERU_API_MAX_CONCURRENT_REQUESTS=12
export MINERU_HYBRID_BATCH_RATIO=16
export MINERU_PDF_RENDER_THREADS=8

# 启动单实例
./start_optimized.sh

# 启动2卡Router模式
./start_router.sh

# 或前台运行（调试）
./start_router_foreground.sh

# 基本启动

# 优化配置启动
docker run -it -u root -d --net=host \
  --privileged \
  --ipc=host \
  --device=/dev/davinci_manager \
  --device=/dev/devmm_svm \
  --device=/dev/hisi_hdc \
  -v /usr/local/Ascend/driver:/usr/local/Ascend/driver \
  -v /usr/local/dcmi:/usr/local/dcmi \
  -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \
  -v /usr/local/sbin:/usr/local/sbin \
  -v /usr/local/Ascend/driver/tools/hccn_tool:/usr/local/Ascend/driver/tools/hccn_tool \
  -v /root/.cache/modelscope/hub/models:/root/.cache/modelscope/hub/models \
  --name mineru-v2 \
  mineru:npu-latest \
  /bin/bash

# 下载官方Dockerfile
wget https://gcore.jsdelivr.net/gh/opendatalab/MinerU@master/docker/china/npu.Dockerfile

# 或从GitHub下载
wget https://raw.githubusercontent.com/opendatalab/MinerU/master/docker/china/npu.Dockerfile

# 查看当前vllm-ascend版本配置
grep "vllm-ascend" npu.Dockerfile

# 修改为指定版本（0.18.0）
sed -i 's/vllm-ascend.*$/vllm-ascend==0.18.0/' npu.Dockerfile

# 或手动编辑
vim npu.Dockerfile
# 找到pip install vllm-ascend相关行
# 修改为：pip install vllm-ascend==0.18.0

# 构建镜像（使用host网络加速下载）
docker build --network=host -t mineru:npu-vllm-0.18.0 -f npu.Dockerfile .

# 构建过程输出
# [+] Building 123.4s (15/15) FINISHED
# => [internal] load build definition from npu.Dockerfile
# => [internal] load .dockerignore
# => [internal] load metadata
# => [1/10] FROM ubuntu:22.04
# => [2/10] RUN apt-get update && apt-get install -y ...
# => [3/10] RUN pip install torch==2.9.0 torch_npu==2.9.0 ...
# => [4/10] RUN pip install vllm==0.18.0 vllm-ascend==0.18.0 ...
# => [5/10] RUN pip install mineru==3.1.1 ...
# ...

# 查看构建结果

# 查看镜像信息
docker inspect mineru:npu-vllm-0.18.0

# 查看镜像内软件版本
docker run --rm mineru:npu-vllm-0.18.0 pip list | grep -E "torch|vllm|mineru"

# 测试启动（不挂载NPU）
docker run --rm mineru:npu-vllm-0.18.0 mineru-api --help

diff --git a/mineru/cli/router.py b/mineru/cli/router.py
index 8d924f3..6cad6d9 100644
--- a/mineru/cli/router.py
+++ b/mineru/cli/router.py
@@ -349,7 +349,10 @@ class ManagedLocalServer:
         env["MINERU_API_OUTPUT_ROOT"] = str(output_root)
         env["MINERU_API_DISABLE_ACCESS_LOG"] = "1"
         if self.gpu is not None:
-            env["CUDA_VISIBLE_DEVICES"] = str(self.gpu)
+            if os.getenv("MINERU_DEVICE_MODE") == "npu":
+                env["ASCEND_RT_VISIBLE_DEVICES"] = str(self.gpu)
+            else:
+                env["CUDA_VISIBLE_DEVICES"] = str(self.gpu)
 
         command = [
             sys.executable,
-- 

# Batch Ratio计算逻辑
if gpu_memory >= 32GB: batch_ratio = 16
elif gpu_memory >= 16GB: batch_ratio = 8
elif gpu_memory >= 12GB: batch_ratio = 4
elif gpu_memory >= 8GB: batch_ratio = 2
else: batch_ratio = 1

用户需求分析
    │
    ├─ 需要公式解析？
    │   ├─ YES → hybrid-auto-engine(full) 或 pipeline(full)
    │   │         精度优先: hybrid (17s, 100%)
    │   │         速度优先: pipeline (16s, 89%)
    │   │
    │   └─ NO → 继续判断
    │
    ├─ 需要表格解析？
    │   ├─ YES → pipeline(full) 或 hybrid(full)
    │   │         推荐: pipeline (2-7s, 100%)
    │   │
    │   └─ NO → 继续判断
    │
    ├─ 需要图片OCR？
    │   ├─ YES → pipeline(lite) 或 hybrid(lite)
    │   │         推荐: pipeline (1.68s, 100%)
    │   │
    │   └─ NO → pipeline(lite/ocr)
    │             推荐: pipeline(ocr) (1.59-1.64s, 最快)
    │
    └─ 复杂排版/VLM需求？
        └─ YES → vlm-auto-engine (6-9s)
        └─ NO → pipeline(lite)

URL="http://localhost:8000"
FILE="$1"
ID=$(curl -s -X POST "$URL/tasks" -F "files=@$FILE" | python3 -c "import sys,json;print(json.load(sys.stdin)['task_id'])")
echo "Task: $ID"
while true; do
    R=$(curl -s "$URL/tasks/$ID")
    S=$(echo "$R" | python3 -c "import sys,json;print(json.load(sys.stdin)['status'])")
    [ "$S" = "completed" ] && echo "$R" && break
    [ "$S" = "failed" ] && echo "$R" && exit 1
    sleep 2
done

# 最快模式 - 仅OCR
curl -X POST http://127.0.0.1:8000/file_parse \
  -F "files=@your_pdf.pdf" \
  -F "backend=pipeline" \
  -F "formula_enable=false" \
  -F "table_enable=false" \
  -F "return_md=true" \
  -F "response_format_zip=true"

# 完整模式 - 含公式表格
curl -X POST http://127.0.0.1:8000/file_parse \
  -F "files=@your_pdf.pdf" \
  -F "backend=pipeline" \
  -F "formula_enable=true" \
  -F "table_enable=true" \
  -F "return_md=true" \
  -F "response_format_zip=true"

# 精度优先
curl -X POST http://127.0.0.1:8000/file_parse \
  -F "files=@your_pdf.pdf" \
  -F "backend=hybrid-auto-engine" \
  -F "formula_enable=true" \
  -F "table_enable=true" \
  -F "return_md=true" \
  -F "response_format_zip=true"

# 速度优先（lite模式）
curl -X POST http://127.0.0.1:8000/file_parse \
  -F "files=@your_pdf.pdf" \
  -F "backend=hybrid-auto-engine" \
  -F "formula_enable=false" \
  -F "table_enable=false" \
  -F "return_md=true" \
  -F "response_format_zip=true"

# VLM模式 - 端到端解析
curl -X POST http://127.0.0.1:8000/file_parse \
  -F "files=@your_pdf.pdf" \
  -F "backend=vlm-auto-engine" \
  -F "return_md=true" \
  -F "response_format_zip=true"

import requests

API_URL = "http://127.0.0.1:8000/file_parse"

def parse_pdf(pdf_path, backend="pipeline", formula=True, table=True):
    """解析PDF文档"""
    with open(pdf_path, 'rb') as f:
        files = {'files': f}
        data = {
            'backend': backend,
            'formula_enable': str(formula).lower(),
            'table_enable': str(table).lower(),
            'return_md': 'true',
            'response_format_zip': 'true'
        }
        response = requests.post(API_URL, files=files, data=data)
        return response.content

# 使用示例
# 最快解析
result = parse_pdf("doc.pdf", backend="pipeline", formula=False, table=False)

# 精度解析
result = parse_pdf("doc.pdf", backend="hybrid-auto-engine", formula=True, table=True)

# VLM解析
result = parse_pdf("doc.pdf", backend="vlm-auto-engine")

#!/bin/bash
# batch_process.sh - 批量处理PDF文档

PDF_DIR="$1"
BACKEND="${2:-pipeline}"
OUTPUT_DIR="${3:-batch_output}"

mkdir -p "$OUTPUT_DIR"

for pdf in "$PDF_DIR"/*.pdf; do
    filename=$(basename "$pdf" .pdf)
    echo "Processing: $filename"
    
    curl -s -X POST http://127.0.0.1:8000/file_parse \
        -F "files=@$pdf" \
        -F "backend=$BACKEND" \
        -F "formula_enable=false" \
        -F "table_enable=false" \
        -F "return_md=true" \
        -F "response_format_zip=true" \
        -o "$OUTPUT_DIR/${filename}.zip"
    
    unzip -o "$OUTPUT_DIR/${filename}.zip" -d "$OUTPUT_DIR/$filename"
done

echo "Batch processing completed!"

# 使用启动脚本（推荐）
cd /root/mineru_start/bin
./start_optimized.sh

# 或手动启动
nohup mineru-api --enable-vlm-preload true --max-concurrency 12 --host 0.0.0.0 --port 8000 > mineru.log 2>&1 &

# 直接启动（前台运行）
cd /root/mineru_start/bin
mineru-api --enable-vlm-preload true --max-concurrency 12 --host 0.0.0.0 --port 8000

# 或使用优化参数前台运行
env MINERU_MODEL_SOURCE=local MINERU_MODEL_DIR=/root/.cache/mineru_models \
    HCCL_OP_EXPANSION_MODE=AIV \
    MINERU_DEVICE_MODE=npu \
    MINERU_API_MAX_CONCURRENT_REQUESTS=12 \
    MINERU_HYBRID_BATCH_RATIO=16 \
    mineru-api \
    --enable-vlm-preload true \
    --max-concurrency 12 \
    --enable_prefix_caching true \
    --gpu-memory-utilization 0.90 \
    --max-num-batched-tokens 8192 \
    --host 0.0.0.0 --port 8000

#!/bin/bash
# start_foreground.sh - 前台运行启动脚本

export MINERU_MODEL_SOURCE=local
export MINERU_MODEL_DIR=/root/.cache/mineru_models
export HCCL_OP_EXPANSION_MODE=AIV
export MINERU_DEVICE_MODE=npu
export MINERU_API_MAX_CONCURRENT_REQUESTS=12
export MINERU_HYBRID_BATCH_RATIO=16
export MINERU_PDF_RENDER_THREADS=8
export MINERU_LOG_LEVEL=INFO

echo "=========================================="
echo "MinerU API Server (Foreground Mode)"
echo "=========================================="
echo "Press Ctrl+C to stop the server"
echo "=========================================="

mineru-api \
    --enable-vlm-preload true \
    --max-concurrency 12 \
    --enable_prefix_caching true \
    --gpu-memory-utilization 0.90 \
    --max-num-batched-tokens 8192 \
    --host 0.0.0.0 --port 8000

#!/bin/bash
# start_router.sh - 2卡Router模式启动脚本（优化配置）

export MINERU_ROUTER_LOCAL_GPUS=0,1
export MINERU_ROUTER_ENABLE_VLM_PRELOAD=true
export MINERU_ROUTER_GPU_MEMORY_UTILIZATION=0.90
export MINERU_API_MAX_CONCURRENT_REQUESTS=12

# 传递额外CLI参数给每个worker（JSON格式）
export MINERU_ROUTER_WORKER_ARGS_JSON='["--enable_prefix_caching", "true", "--max-num-batched-tokens", "8192"]'

nohup mineru-router \
    --host 0.0.0.0 \
    --port 8000 \
    --local-gpus "0,1" \
    --enable-vlm-preload true \
    > mineru_router.log 2>&1 &

#!/bin/bash
# start_router_foreground.sh - 2卡Router前台运行（优化配置）

export MINERU_ROUTER_LOCAL_GPUS=0,1
export MINERU_ROUTER_ENABLE_VLM_PRELOAD=true
export MINERU_ROUTER_GPU_MEMORY_UTILIZATION=0.90
export MINERU_API_MAX_CONCURRENT_REQUESTS=12
export MINERU_ROUTER_WORKER_ARGS_JSON='["--enable_prefix_caching", "true", "--max-num-batched-tokens", "8192"]'

echo "MinerU Router (2-NPU, Foreground)"
echo "Press Ctrl+C to stop"

mineru-router \
    --host 0.0.0.0 \
    --port 8000 \
    --local-gpus "0,1" \
    --enable-vlm-preload true

# JSON数组格式，传递CLI参数给每个worker
export MINERU_ROUTER_WORKER_ARGS_JSON='["--enable_prefix_caching", "true", "--max-num-batched-tokens", "8192"]'

# 多个参数示例
export MINERU_ROUTER_WORKER_ARGS_JSON='["--enable_prefix_caching", "true", "--max-num-batched-tokens", "8192", "--max-concurrency", "12"]'