paddlex 3.0.1__py3-none-any.whl → 3.0.2__py3-none-any.whl

paddlex/inference/utils/misc.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def is_mkldnn_available():
+    # XXX: Not sure if this is the best way to check if MKL-DNN is available
+    from paddle.inference import Config
+
+    return hasattr(Config, "set_mkldnn_cache_capacity")

paddlex/inference/utils/mkldnn_blocklist.py

@@ -13,12 +13,46 @@
 # limitations under the License.
 
 MKLDNN_BLOCKLIST = [
-    "SLANeXt_wired",
-    "SLANeXt_wireless",
     "LaTeX_OCR_rec",
     "PP-FormulaNet-L",
     "PP-FormulaNet-S",
     "UniMERNet",
+    "UVDoc",
+    "Cascade-MaskRCNN-ResNet50-FPN",
+    "Cascade-MaskRCNN-ResNet50-vd-SSLDv2-FPN",
+    "Mask-RT-DETR-M",
+    "Mask-RT-DETR-S",
+    "MaskRCNN-ResNeXt101-vd-FPN",
+    "MaskRCNN-ResNet101-FPN",
+    "MaskRCNN-ResNet101-vd-FPN",
+    "MaskRCNN-ResNet50-FPN",
+    "MaskRCNN-ResNet50-vd-FPN",
+    "MaskRCNN-ResNet50",
+    "SOLOv2",
+    "PP-TinyPose_128x96",
+    "PP-TinyPose_256x192",
+    "Cascade-FasterRCNN-ResNet50-FPN",
+    "Cascade-FasterRCNN-ResNet50-vd-SSLDv2-FPN",
+    "Co-DINO-Swin-L",
+    "Co-Deformable-DETR-Swin-T",
+    "FasterRCNN-ResNeXt101-vd-FPN",
+    "FasterRCNN-ResNet101-FPN",
+    "FasterRCNN-ResNet101",
+    "FasterRCNN-ResNet34-FPN",
+    "FasterRCNN-ResNet50-FPN",
+    "FasterRCNN-ResNet50-vd-FPN",
+    "FasterRCNN-ResNet50-vd-SSLDv2-FPN",
+    "FasterRCNN-ResNet50",
+    "FasterRCNN-Swin-Tiny-FPN",
+    "MaskFormer_small",
+    "MaskFormer_tiny",
+    "SLANeXt_wired",
+    "SLANeXt_wireless",
+    "SLANet",
+    "SLANet_plus",
+    "YOWO",
+    "SAM-H_box",
+    "SAM-H_point",
     "PP-FormulaNet_plus-L",
     "PP-FormulaNet_plus-M",
     "PP-FormulaNet_plus-S",

paddlex/inference/utils/official_models.py

@@ -12,11 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+import shutil
+import tempfile
+from functools import lru_cache
 from pathlib import Path
 
+import huggingface_hub as hf_hub
+
+hf_hub.logging.set_verbosity_error()
+
+import requests
+
 from ...utils import logging
 from ...utils.cache import CACHE_DIR
 from ...utils.download import download_and_extract
+from ...utils.flags import MODEL_SOURCE
 
 OFFICIAL_MODELS = {
     "ResNet18": "https://paddle-model-ecology.bj.bcebos.com/paddlex/official_inference_model/paddle3.0.0/ResNet18_infer.tar",
@@ -352,17 +363,127 @@ PP-OCRv5_mobile_rec_infer.tar",
 }
 
 
+HUGGINGFACE_MODELS = [
+    "arabic_PP-OCRv3_mobile_rec",
+    "chinese_cht_PP-OCRv3_mobile_rec",
+    "ch_RepSVTR_rec",
+    "ch_SVTRv2_rec",
+    "cyrillic_PP-OCRv3_mobile_rec",
+    "devanagari_PP-OCRv3_mobile_rec",
+    "en_PP-OCRv3_mobile_rec",
+    "en_PP-OCRv4_mobile_rec",
+    "japan_PP-OCRv3_mobile_rec",
+    "ka_PP-OCRv3_mobile_rec",
+    "korean_PP-OCRv3_mobile_rec",
+    "LaTeX_OCR_rec",
+    "latin_PP-OCRv3_mobile_rec",
+    "PicoDet_layout_1x",
+    "PicoDet_layout_1x_table",
+    "PicoDet-L_layout_17cls",
+    "PicoDet-L_layout_3cls",
+    "PicoDet-S_layout_17cls",
+    "PicoDet-S_layout_3cls",
+    "PP-DocBee2-3B",
+    "PP-DocBee-2B",
+    "PP-DocBee-7B",
+    "PP-DocBlockLayout",
+    "PP-DocLayout-L",
+    "PP-DocLayout-M",
+    "PP-DocLayout_plus-L",
+    "PP-DocLayout-S",
+    "PP-FormulaNet-L",
+    "PP-FormulaNet_plus-L",
+    "PP-FormulaNet_plus-M",
+    "PP-FormulaNet_plus-S",
+    "PP-FormulaNet-S",
+    "PP-LCNet_x1_0_doc_ori",
+    "PP-LCNet_x1_0_table_cls",
+    "PP-OCRv3_mobile_det",
+    "PP-OCRv3_mobile_rec",
+    "PP-OCRv3_server_det",
+    "PP-OCRv4_mobile_det",
+    "PP-OCRv4_mobile_rec",
+    "PP-OCRv4_mobile_seal_det",
+    "PP-OCRv4_server_det",
+    "PP-OCRv4_server_rec_doc",
+    "PP-OCRv4_server_rec",
+    "PP-OCRv4_server_seal_det",
+    "PP-OCRv5_mobile_det",
+    "PP-OCRv5_mobile_rec",
+    "PP-OCRv5_server_det",
+    "PP-OCRv5_server_rec",
+    "RT-DETR-H_layout_17cls",
+    "RT-DETR-H_layout_3cls",
+    "RT-DETR-L_wired_table_cell_det",
+    "RT-DETR-L_wireless_table_cell_det",
+    "SLANet",
+    "SLANet_plus",
+    "SLANeXt_wired",
+    "SLANeXt_wireless",
+    "ta_PP-OCRv3_mobile_rec",
+    "te_PP-OCRv3_mobile_rec",
+    "UniMERNet",
+    "UVDoc",
+]
+
+
+@lru_cache(1)
+def is_huggingface_accessible():
+    try:
+        response = requests.get("https://huggingface.co", timeout=1)
+        return response.ok == True
+    except requests.exceptions.RequestException as e:
+        return False
+
+
 class OfficialModelsDict(dict):
     """Official Models Dict"""
 
+    _save_dir = Path(CACHE_DIR) / "official_models"
+
     def __getitem__(self, key):
-        url = super().__getitem__(key)
-        save_dir = Path(CACHE_DIR) / "official_models"
+        def _download_from_bos():
+            url = super(OfficialModelsDict, self).__getitem__(key)
+            download_and_extract(url, self._save_dir, f"{key}", overwrite=False)
+            return self._save_dir / f"{key}"
+
+        def _download_from_hf():
+            local_dir = self._save_dir / f"{key}"
+            try:
+                if os.path.exists(local_dir):
+                    hf_hub.snapshot_download(
+                        repo_id=f"PaddlePaddle/{key}", local_dir=local_dir
+                    )
+                else:
+                    with tempfile.TemporaryDirectory() as td:
+                        temp_dir = os.path.join(td, "temp_dir")
+                        hf_hub.snapshot_download(
+                            repo_id=f"PaddlePaddle/{key}", local_dir=temp_dir
+                        )
+                        shutil.move(temp_dir, local_dir)
+            except Exception as e:
+                logging.warning(
+                    f"Encounter exception when download model from huggingface: \n{e}.\nPaddleX would try to download from BOS."
+                )
+                return _download_from_bos()
+            return local_dir
+
         logging.info(
-            f"Using official model ({key}), the model files will be automatically downloaded and saved in {save_dir}."
+            f"Using official model ({key}), the model files will be automatically downloaded and saved in {self._save_dir}."
         )
-        download_and_extract(url, save_dir, f"{key}", overwrite=False)
-        return save_dir / f"{key}"
+
+        if (
+            MODEL_SOURCE.lower() == "huggingface"
+            and is_huggingface_accessible()
+            and key in HUGGINGFACE_MODELS
+        ):
+            return _download_from_hf()
+        elif MODEL_SOURCE.lower() == "modelscope":
+            raise Exception(
+                f"ModelScope is not supported! Please use `HuggingFace` or `BOS`."
+            )
+        else:
+            return _download_from_bos()
 
 
 official_models = OfficialModelsDict(OFFICIAL_MODELS)

paddlex/inference/utils/pp_option.py

@@ -23,13 +23,34 @@ from ...utils.device import (
     parse_device,
     set_env_for_device_type,
 )
-from ...utils.flags import USE_PIR_TRT
+from ...utils.flags import (
+    DISABLE_MKLDNN_MODEL_BL,
+    DISABLE_TRT_MODEL_BL,
+    ENABLE_MKLDNN_BYDEFAULT,
+    USE_PIR_TRT,
+)
+from .misc import is_mkldnn_available
 from .mkldnn_blocklist import MKLDNN_BLOCKLIST
 from .new_ir_blocklist import NEWIR_BLOCKLIST
 from .trt_blocklist import TRT_BLOCKLIST
 from .trt_config import TRT_CFG_SETTING, TRT_PRECISION_MAP
 
 
+def get_default_run_mode(model_name, device_type):
+    if not model_name:
+        return "paddle"
+    if device_type != "cpu":
+        return "paddle"
+    if (
+        ENABLE_MKLDNN_BYDEFAULT
+        and is_mkldnn_available()
+        and model_name not in MKLDNN_BLOCKLIST
+    ):
+        return "mkldnn"
+    else:
+        return "paddle"
+
+
 class PaddlePredictorOption(object):
     """Paddle Inference Engine Option"""
 
@@ -104,7 +125,7 @@ class PaddlePredictorOption(object):
         device_type, device_ids = parse_device(get_default_device())
 
         default_config = {
-            "run_mode": "paddle",
+            "run_mode": get_default_run_mode(self.model_name, device_type),
             "device_type": device_type,
             "device_id": None if device_ids is None else device_ids[0],
             "cpu_threads": 8,
@@ -119,6 +140,7 @@ class PaddlePredictorOption(object):
             "trt_dynamic_shape_input_data": None,  # only for trt
             "trt_shape_range_info_path": None,  # only for trt
             "trt_allow_rebuild_at_runtime": True,  # only for trt
+            "mkldnn_cache_capacity": 10,
         }
         return default_config
 
@@ -139,15 +161,29 @@ class PaddlePredictorOption(object):
                 f"`run_mode` must be {support_run_mode_str}, but received {repr(run_mode)}."
             )
 
+        if run_mode.startswith("mkldnn") and not is_mkldnn_available():
+            logging.warning("MKL-DNN is not available. Using `paddle` instead.")
+            run_mode = "paddle"
+
+        # TODO: Check if trt is available
+
         if self._model_name is not None:
             # TRT Blocklist
-            if run_mode.startswith("trt") and self._model_name in TRT_BLOCKLIST:
+            if (
+                not DISABLE_TRT_MODEL_BL
+                and run_mode.startswith("trt")
+                and self._model_name in TRT_BLOCKLIST
+            ):
                 logging.warning(
                     f"The model({self._model_name}) is not supported to run in trt mode! Using `paddle` instead!"
                 )
                 run_mode = "paddle"
             # MKLDNN Blocklist
-            elif run_mode.startswith("mkldnn") and self._model_name in MKLDNN_BLOCKLIST:
+            elif (
+                not DISABLE_MKLDNN_MODEL_BL
+                and run_mode.startswith("mkldnn")
+                and self._model_name in MKLDNN_BLOCKLIST
+            ):
                 logging.warning(
                     f"The model({self._model_name}) is not supported to run in MKLDNN mode! Using `paddle` instead!"
                 )
@@ -294,6 +330,14 @@ class PaddlePredictorOption(object):
     def trt_allow_rebuild_at_runtime(self, trt_allow_rebuild_at_runtime):
         self._update("trt_allow_rebuild_at_runtime", trt_allow_rebuild_at_runtime)
 
+    @property
+    def mkldnn_cache_capacity(self):
+        return self._cfg["mkldnn_cache_capacity"]
+
+    @mkldnn_cache_capacity.setter
+    def mkldnn_cache_capacity(self, capacity: int):
+        self._update("mkldnn_cache_capacity", capacity)
+
     # For backward compatibility
     # TODO: Issue deprecation warnings
     @property

paddlex/modules/semantic_segmentation/dataset_checker/__init__.py

@@ -38,8 +38,18 @@ class SegDatasetChecker(BaseDatasetChecker):
             str: the root directory of dataset.
         """
         anno_dirs = list(Path(dataset_dir).glob("**/images"))
-        assert len(anno_dirs) == 1
-        dataset_dir = anno_dirs[0].parent.as_posix()
+        if len(anno_dirs) == 1:
+            dataset_dir = anno_dirs[0].parent.as_posix()
+        elif len(anno_dirs) == 0:
+            dataset_dir = Path(dataset_dir)
+        else:
+            raise ValueError(
+                f"Segmentation Dataset Format Error: We currently only support `PaddleX` and `Labelme` formats. "
+                f"For `PaddleX` format, your dataset root must contain exactly one `images` directory. "
+                f"For `Labelme` format, your dataset root must contain no `images` directories. "
+                f"However, your dataset root contains {len(anno_dirs)} `images` directories. "
+                f"Please adjust your dataset structure to comply with the supported formats."
+            )
         return dataset_dir
 
     def convert_dataset(self, src_dataset_dir: str) -> str:

paddlex/ops/__init__.py

@@ -66,11 +66,14 @@ class CustomOpNotFoundException(Exception):
 
 
 class CustomOperatorPathFinder:
-    def find_module(self, fullname: str, path: str = None):
+    def find_spec(self, fullname: str, path, target=None):
         if not fullname.startswith("paddlex.ops"):
             return None
-
-        return CustomOperatorPathLoader()
+        return importlib.machinery.ModuleSpec(
+            name=fullname,
+            loader=CustomOperatorPathLoader(),
+            is_package=False,        
+        )
 
 
 class CustomOperatorPathLoader:

paddlex/utils/deps.py

@@ -73,7 +73,7 @@ def _get_dep_specs():
 DEP_SPECS = _get_dep_specs()
 
 
-def _get_dep_version(dep):
+def get_dep_version(dep):
     try:
         return importlib.metadata.version(dep)
     except importlib.metadata.PackageNotFoundError:
@@ -101,7 +101,7 @@ def is_dep_available(dep, /, check_version=None):
             check_version = True
         else:
             check_version = False
-    version = _get_dep_version(dep)
+    version = get_dep_version(dep)
     if version is None:
         return False
     if check_version:

paddlex/utils/device.py

@@ -15,8 +15,6 @@
 import os
 from contextlib import ContextDecorator
 
-import GPUtil
-
 from . import logging
 from .custom_device_list import (
     DCU_WHITELIST,
@@ -41,25 +39,12 @@ def constr_device(device_type, device_ids):
 
 
 def get_default_device():
-    try:
-        gpu_list = GPUtil.getGPUs()
-    except Exception:
-        logging.debug(
-            "Failed to query GPU devices. Falling back to CPU.", exc_info=True
-        )
-        has_gpus = False
+    import paddle
+
+    if paddle.device.is_compiled_with_cuda() and paddle.device.cuda.device_count() > 0:
+        return constr_device("gpu", [0])
     else:
-        has_gpus = bool(gpu_list)
-    if not has_gpus:
-        # HACK
-        if os.path.exists("/etc/nv_tegra_release"):
-            logging.debug(
-                "The current device appears to be an NVIDIA Jetson. GPU 0 will be used as the default device."
-            )
-    if not has_gpus:
         return "cpu"
-    else:
-        return constr_device("gpu", [0])
 
 
 def parse_device(device):

paddlex/utils/flags.py

@@ -51,7 +51,16 @@ FLAGS_json_format_model = get_flag_from_env_var("FLAGS_json_format_model", True)
 USE_PIR_TRT = get_flag_from_env_var("PADDLE_PDX_USE_PIR_TRT", True)
 DISABLE_DEV_MODEL_WL = get_flag_from_env_var("PADDLE_PDX_DISABLE_DEV_MODEL_WL", False)
 DISABLE_CINN_MODEL_WL = get_flag_from_env_var("PADDLE_PDX_DISABLE_CINN_MODEL_WL", False)
+DISABLE_TRT_MODEL_BL = get_flag_from_env_var("PADDLE_PDX_DISABLE_TRT_MODEL_BL", False)
+DISABLE_MKLDNN_MODEL_BL = get_flag_from_env_var(
+    "PADDLE_PDX_DISABLE_MKLDNN_MODEL_BL", False
+)
 LOCAL_FONT_FILE_PATH = get_flag_from_env_var("PADDLE_PDX_LOCAL_FONT_FILE_PATH", None)
+ENABLE_MKLDNN_BYDEFAULT = get_flag_from_env_var(
+    "PADDLE_PDX_ENABLE_MKLDNN_BYDEFAULT", True
+)
+
+MODEL_SOURCE = os.environ.get("PADDLE_PDX_MODEL_SOURCE", "huggingface")
 
 
 # Inference Benchmark

paddlex/utils/subclass_register.py

@@ -46,7 +46,7 @@ class AutoRegisterMetaClass(type):
         if bases:
             for base in bases:
                 base_cls = mcs.__find_base_class(base)
-                if base_cls:
+                if base_cls and hasattr(cls, mcs.__model_type_attr_name):
                     mcs.__register_to_base_class(base_cls, cls)
 
     @classmethod
@@ -64,7 +64,7 @@ class AutoRegisterMetaClass(type):
 
     @classmethod
     def __register_to_base_class(mcs, base, cls):
-        cls_entity_name = getattr(cls, mcs.__model_type_attr_name, cls.__name__)
+        cls_entity_name = getattr(cls, mcs.__model_type_attr_name)
         if isinstance(cls_entity_name, str):
             cls_entity_name = [cls_entity_name]