feat: paddleocr v6 (#2320)

* feat: intro PP-OCRv6

* perf: enchante OCR components

* feat: add 'ppocrv6_small' to OCR model options

* feat: optimize PP-OCRv6 inference, add directdml and warmups

* perf: revoke bad changes

* feat: update model path handling in ONNX OCR integration

* fix(ocr): fix OCR model hot reload config not taking effect

* feat(ocr): add support for ppocrv6_tiny model

* fix: update self logging module

* fix(ocr): remove duplicate shadowed log import in predict_base

* refactor(ocr): enforce strict list pairing using zip(strict=True)

* fix(ocr): support medium size fallback and handle missing dict file in OnnxOcrParam

* fix(ocr): invoke cleanup during OCR reinitialization to prevent memory leaks

* style(ocr): add type annotations for ocr_model_size and to_dict in OnnxOcrParam

* refactor(ocr): replace **kwargs with explicit params and add type annotations/docstring for ocr()

* refactor(ocr): use ppocrv6 small model only

* refactor(ocr): remove redundant ppocrv6 model normalization

Author: A-nony-mous

src/one_dragon/base/config/basic_model_config.py

@@ -1,7 +1,13 @@
 from one_dragon.base.config.config_item import ConfigItem
 from one_dragon.base.config.yaml_config import YamlConfig
-from one_dragon.base.matcher.ocr.onnx_ocr_matcher import DEFAULT_OCR_MODEL_NAME, get_ocr_model_dir, \
-    get_ocr_download_url_github, get_ocr_download_url_gitee, get_final_file_list
+from one_dragon.base.matcher.ocr.onnx_ocr_matcher import (
+    DEFAULT_OCR_MODEL_NAME,
+    PPOCRV6_MODEL_NAME,
+    get_final_file_list,
+    get_ocr_download_url_gitee,
+    get_ocr_download_url_github,
+    get_ocr_model_dir,
+)
 from one_dragon.base.web.common_downloader import CommonDownloaderParam
 
 
@@ -34,7 +40,7 @@ def using_old_model(self) -> bool:
         pass
 
 def get_ocr_opts() -> list[ConfigItem]:
-    models_list = [DEFAULT_OCR_MODEL_NAME]
+    models_list = [DEFAULT_OCR_MODEL_NAME, PPOCRV6_MODEL_NAME]
     config_list: list[ConfigItem] = []
     for model in models_list:
         model_dir = get_ocr_model_dir(model)

src/one_dragon/base/matcher/ocr/onnx_ocr_matcher.py

@@ -3,6 +3,7 @@
 import time
 from collections.abc import Callable
 from logging import DEBUG
+from typing import Any
 
 from cv2.typing import MatLike
 
@@ -17,6 +18,7 @@
 from one_dragon.utils.log_utils import log
 
 DEFAULT_OCR_MODEL_NAME: str = 'ppocrv5'
+PPOCRV6_MODEL_NAME: str = 'ppocrv6'
 GITHUB_DOWNLOAD_URL: str = 'https://github.com/OneDragon-Anything/OneDragon-Env/releases/download'
 GITEE_DOWNLOAD_URL: str = 'https://gitee.com/OneDragon-Anything/OneDragon-Env/releases/download'
 
@@ -37,20 +39,35 @@ def get_ocr_download_url(website: str, ocr_model_name: str) -> str:
     return f'{website}/{ocr_model_name}/{ocr_model_name}.zip'
 
 
+def get_ocr_model_dict_name(ocr_model_name: str) -> str | None:
+    """
+    获取模型对应的字典文件名。直接扫描本地文件夹中的字典文件。
+    """
+    base_dir = get_ocr_model_dir(ocr_model_name)
+    if os.path.exists(base_dir):
+        for f in os.listdir(base_dir):
+            if f.endswith('_dict.txt'):
+                return f
+    return None
+
+
 def get_final_file_list(ocr_model_name: str) -> list[str]:
     """
     下载成功后 整个模型的所有文件
     :param ocr_model_name: 模型名称
     :return:
     """
     base_dir = get_ocr_model_dir(ocr_model_name)
-    return [
+    files = [
         os.path.join(base_dir, 'det.onnx'),
         os.path.join(base_dir, 'rec.onnx'),
         os.path.join(base_dir, 'cls.onnx'),
-        os.path.join(base_dir, 'ppocrv5_dict.txt'),
         os.path.join(base_dir, 'simfang.ttf'),
     ]
+    dict_name = get_ocr_model_dict_name(ocr_model_name)
+    if dict_name is not None:
+        files.append(os.path.join(base_dir, dict_name))
+    return files
 
 
 class OnnxOcrParam:
@@ -65,14 +82,20 @@ def __init__(
             det_model_name: str = 'det.onnx',
             rec_model_name: str = 'rec.onnx',
             cls_model_name: str = 'cls.onnx',
-            dict_name: str = 'ppocrv5_dict.txt',
+            dict_name: str | None = None,
             font_name: str = 'simfang.ttf',
             use_gpu: bool = False,
             use_angle_cls: bool = False,
             det_limit_side_len: float = 960.0,
+            ocr_model_size: str | None = None,
     ):
         self.ocr_model_name: str = ocr_model_name
         self.models_dir: str = get_ocr_model_dir(ocr_model_name)
+        if dict_name is None:
+            dict_name = get_ocr_model_dict_name(ocr_model_name)
+            if dict_name is None:
+                # 首次运行未下载时，根据模型名推导一个默认的字典文件名，避免崩溃
+                dict_name = f"{self.ocr_model_name}_dict.txt"
         # ===================================================================
         # I. 设备与性能 (Device & Performance)
         # ===================================================================
@@ -91,13 +114,16 @@ def __init__(
         # III. 核心功能开关 (Core Feature Switches)
         # ===================================================================
         self.use_angle_cls = use_angle_cls  # 是否加载并使用方向分类模型
+        if self.ocr_model_name == PPOCRV6_MODEL_NAME or ocr_model_size is None:
+            ocr_model_size = 'small'
+        self.ocr_model_size: str | None = ocr_model_size
 
         # ===================================================================
         # IV. 文字检测超参数 (Detection Hyperparameters)
         # ===================================================================
         self.det_limit_side_len = det_limit_side_len  # 输入图像的长边限制
 
-    def to_dict(self):
+    def to_dict(self) -> dict[str, Any]:
         """将OCR配置转换为字典格式"""
         return {
             'use_gpu': self.use_gpu,
@@ -108,6 +134,7 @@ def to_dict(self):
             'vis_font_path': self.vis_font_path,
             'use_angle_cls': self.use_angle_cls,
             'det_limit_side_len': self.det_limit_side_len,
+            'ocr_model_size': self.ocr_model_size,
         }
 
 
@@ -213,6 +240,15 @@ def init_model(
                 log.error('OCR模型加载出错', exc_info=True)
                 return False
 
+    def cleanup(self) -> None:
+        """
+        释放底层模型实例资源，协助 GC 回收 ONNX 会话
+        """
+        with self._init_lock:
+            if self._model is not None:
+                del self._model
+                self._model = None
+
     def update_use_gpu(self, use_gpu: bool) -> None:
         """
         更新是否使用GPU
@@ -358,7 +394,7 @@ def match_words(
         """
         all_match_result: dict = self.run_ocr(image, threshold, merge_line_distance=merge_line_distance)
         match_key = set()
-        for k in all_match_result.keys():
+        for k in all_match_result:
             for w in words:
                 ocr_result: str = k
                 ocr_target = gt(w, 'ocr')
@@ -491,7 +527,7 @@ def _emit_overlay_vision_from_ocr_results(
             return
 
         offset_x, offset_y = bus.crop_offset
-        for i, result in enumerate(ocr_results[:60]):
+        for result in ocr_results[:60]:
             label = str(result.data or "").strip()
             if len(label) > 32:
                 label = label[:29] + "..."

src/one_dragon/base/operation/one_dragon_context.py

@@ -484,7 +484,22 @@ def init_ocr(self) -> None:
         初始化OCR
         :return:
         """
-        self.ocr.update_use_gpu(self.model_config.ocr_use_gpu)
+        # 清理旧实例资源
+        if hasattr(self, 'ocr') and self.ocr is not None:
+            if hasattr(self.ocr, 'cleanup'):
+                self.ocr.cleanup()
+
+        self.ocr = OnnxOcrMatcher(
+            OnnxOcrParam(
+                ocr_model_name=self.model_config.ocr,
+                use_gpu=self.model_config.ocr_use_gpu,
+                det_limit_side_len=max(self.project_config.screen_standard_width, self.project_config.screen_standard_height),
+            )
+        )
+        self.ocr.overlay_debug_bus = self.overlay_debug_bus
+        self.ocr_service.ocr_matcher = self.ocr
+        if 'cv_service' in self.__dict__:
+            self.cv_service.ocr = self.ocr
         self.ocr.init_model(
             ghproxy_url=self.env_config.gh_proxy_url if self.env_config.is_gh_proxy else None,
             proxy_url=self.env_config.personal_proxy if self.env_config.is_personal_proxy else None,

src/onnxocr/inference_engine.py

@@ -0,0 +1,178 @@
+import os
+import platform
+from collections.abc import Sequence
+from enum import Enum
+from typing import Any
+
+import onnxruntime
+
+from onnxocr.logger import get_logger
+
+log = get_logger("inference_engine")
+
+
+Provider = str | tuple[str, dict[str, Any]]
+
+
+InferenceSession = onnxruntime.InferenceSession
+SessionOptions = onnxruntime.SessionOptions
+GraphOptimizationLevel = onnxruntime.GraphOptimizationLevel
+
+
+class EP(Enum):
+    CPU = "CPUExecutionProvider"
+    CUDA = "CUDAExecutionProvider"
+    DIRECTML = "DmlExecutionProvider"
+    CANN = "CANNExecutionProvider"
+
+
+DEFAULT_CPU_EP_CFG: dict[str, Any] = {}
+DEFAULT_CUDA_EP_CFG: dict[str, Any] = {
+    "cudnn_conv_algo_search": "DEFAULT",
+    "device_id": 0,
+}
+DEFAULT_DML_EP_CFG: dict[str, Any] = {}
+DEFAULT_CANN_EP_CFG: dict[str, Any] = {}
+
+
+def get_available_providers() -> list[str]:
+    return onnxruntime.get_available_providers()
+
+
+def get_device() -> str:
+    return onnxruntime.get_device()
+
+
+def is_session(value: Any) -> bool:
+    return isinstance(value, InferenceSession)
+
+
+def build_providers(
+    use_gpu: bool = False,
+    gpu_id: int = 0,
+    providers: Sequence[Provider] | None = None,
+) -> list[Provider]:
+    if providers is not None:
+        return list(providers)
+
+    if use_gpu:
+        available = get_available_providers()
+        if EP.CUDA.value in available:
+            cuda_cfg = dict(DEFAULT_CUDA_EP_CFG)
+            cuda_cfg["device_id"] = gpu_id
+            return [(EP.CUDA.value, cuda_cfg), EP.CPU.value]
+        elif EP.DIRECTML.value in available:
+            return [EP.DIRECTML.value, EP.CPU.value]
+        elif EP.CANN.value in available:
+            return [EP.CANN.value, EP.CPU.value]
+    return [EP.CPU.value]
+
+
+def build_providers_from_engine_cfg(engine_cfg: Any) -> list[Provider]:
+    """Build ONNXRuntime execution providers from the common engine_cfg shape.
+
+    RapidTable, RapidLayout and RapidDoc use slightly different vendored copies of
+    an ``engine_cfg`` object. This function is the single compatibility point so
+    downstream vendors only need to customize provider behavior here.
+    """
+
+    available = get_available_providers()
+    providers: list[Provider] = [(EP.CPU.value, _cfg_dict(engine_cfg, "cpu_ep_cfg", DEFAULT_CPU_EP_CFG))]
+
+    if _cfg_bool(engine_cfg, "use_cuda") and EP.CUDA.value in available:
+        providers.insert(0, (EP.CUDA.value, _cfg_dict(engine_cfg, "cuda_ep_cfg", DEFAULT_CUDA_EP_CFG)))
+
+    if _cfg_bool(engine_cfg, "use_dml") and _is_windows() and EP.DIRECTML.value in available:
+        providers.insert(0, (EP.DIRECTML.value, _cfg_dict(engine_cfg, "dm_ep_cfg", DEFAULT_DML_EP_CFG)))
+
+    if _cfg_bool(engine_cfg, "use_cann") and EP.CANN.value in available:
+        providers.insert(0, (EP.CANN.value, _cfg_dict(engine_cfg, "cann_ep_cfg", DEFAULT_CANN_EP_CFG)))
+
+    return providers
+
+
+class ProviderConfig:
+    """Compatibility wrapper used by vendored RapidAI modules."""
+
+    def __init__(self, engine_cfg: Any):
+        self.engine_cfg = engine_cfg
+
+    def get_ep_list(self) -> list[Provider]:
+        return build_providers_from_engine_cfg(self.engine_cfg)
+
+    def verify_providers(self, session_providers: Sequence[str]) -> None:
+        if not session_providers:
+            raise ValueError("Session providers is empty.")
+
+
+def _cfg_bool(engine_cfg: Any, key: str, default: bool = False) -> bool:
+    value = _cfg_get(engine_cfg, key, default)
+    return bool(value)
+
+
+def _cfg_dict(engine_cfg: Any, key: str, default: dict[str, Any]) -> dict[str, Any]:
+    result = dict(default)
+    value = _cfg_get(engine_cfg, key, default)
+    if value is not None:
+        result.update(dict(value))
+
+    prefix = f"{key}."
+    if hasattr(engine_cfg, "items"):
+        for cfg_key, cfg_value in engine_cfg.items():
+            if isinstance(cfg_key, str) and cfg_key.startswith(prefix):
+                result[cfg_key[len(prefix) :]] = cfg_value
+    return result
+
+
+def _cfg_get(engine_cfg: Any, key: str, default: Any = None) -> Any:
+    if engine_cfg is None:
+        return default
+    if hasattr(engine_cfg, "get"):
+        return engine_cfg.get(key, default)
+    return getattr(engine_cfg, key, default)
+
+
+def _is_windows() -> bool:
+    return platform.system() == "Windows"
+
+
+def _default_session_options() -> SessionOptions:
+    """Build a SessionOptions with graph optimization and memory pattern enabled.
+
+    These settings provide 10-30% CPU inference speedup with no accuracy impact.
+    """
+    opts = SessionOptions()
+    opts.graph_optimization_level = GraphOptimizationLevel.ORT_ENABLE_ALL
+    opts.enable_mem_pattern = True
+    return opts
+
+
+def create_session(
+    model_path: str,
+    providers: Sequence[Provider] | None = None,
+    use_gpu: bool = False,
+    gpu_id: int = 0,
+    sess_options: SessionOptions | None = None,
+) -> InferenceSession:
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(
+            f"Model file not found: {model_path}. "
+            f"Please download models first: python scripts/download_models.py"
+        )
+    if sess_options is None:
+        sess_options = _default_session_options()
+    session_providers = build_providers(
+        use_gpu=use_gpu,
+        gpu_id=gpu_id,
+        providers=providers,
+    )
+    log.info("Creating ONNX session: {}, providers={}", model_path, session_providers)
+    try:
+        return InferenceSession(
+            model_path,
+            sess_options=sess_options,
+            providers=session_providers,
+        )
+    except Exception as e:
+        log.error("Failed to load model: {}, error: {}", model_path, e)
+        raise