paddlex 3.0.1__py3-none-any.whl → 3.0.3__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"""
 
@@ -48,6 +69,7 @@ class PaddlePredictorOption(object):
 
     def __init__(self, model_name=None, **kwargs):
         super().__init__()
+        self._is_default_run_mode = True
         self._model_name = model_name
         self._cfg = {}
         self._init_option(**kwargs)
@@ -85,6 +107,10 @@ class PaddlePredictorOption(object):
                 raise Exception(
                     f"{k} is not supported to set! The supported option is: {self._get_settable_attributes()}"
                 )
+
+        if "run_mode" in self._cfg:
+            self._is_default_run_mode = False
+
         for k, v in self._get_default_config().items():
             self._cfg.setdefault(k, v)
 
@@ -101,12 +127,16 @@ class PaddlePredictorOption(object):
 
     def _get_default_config(self):
         """get default config"""
-        device_type, device_ids = parse_device(get_default_device())
+        if self.device_type is None:
+            device_type, device_ids = parse_device(get_default_device())
+            device_id = None if device_ids is None else device_ids[0]
+        else:
+            device_type, device_id = self.device_type, self.device_id
 
         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],
+            "device_id": device_id,
             "cpu_threads": 8,
             "delete_pass": [],
             "enable_new_ir": True if self.model_name not in NEWIR_BLOCKLIST else False,
@@ -119,6 +149,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
 
@@ -126,9 +157,15 @@ class PaddlePredictorOption(object):
         self._cfg[k] = v
         self.changed = True
 
+    def reset_run_mode_by_default(self, model_name=None, device_type=None):
+        if self._is_default_run_mode:
+            model_name = model_name or self.model_name
+            device_type = device_type or self.device_type
+            self._update("run_mode", get_default_run_mode(model_name, device_type))
+
     @property
     def run_mode(self):
-        return self._cfg["run_mode"]
+        return self._cfg.get("run_mode")
 
     @run_mode.setter
     def run_mode(self, run_mode: str):
@@ -139,25 +176,40 @@ 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!"
                 )
                 run_mode = "paddle"
 
+        self._is_default_run_mode = False
         self._update("run_mode", run_mode)
 
     @property
     def device_type(self):
-        return self._cfg["device_type"]
+        return self._cfg.get("device_type")
 
     @device_type.setter
     def device_type(self, device_type):
@@ -175,7 +227,7 @@ class PaddlePredictorOption(object):
 
     @property
     def device_id(self):
-        return self._cfg["device_id"]
+        return self._cfg.get("device_id")
 
     @device_id.setter
     def device_id(self, device_id):
@@ -183,7 +235,7 @@ class PaddlePredictorOption(object):
 
     @property
     def cpu_threads(self):
-        return self._cfg["cpu_threads"]
+        return self._cfg.get("cpu_threads")
 
     @cpu_threads.setter
     def cpu_threads(self, cpu_threads):
@@ -194,7 +246,7 @@ class PaddlePredictorOption(object):
 
     @property
     def delete_pass(self):
-        return self._cfg["delete_pass"]
+        return self._cfg.get("delete_pass")
 
     @delete_pass.setter
     def delete_pass(self, delete_pass):
@@ -202,7 +254,7 @@ class PaddlePredictorOption(object):
 
     @property
     def enable_new_ir(self):
-        return self._cfg["enable_new_ir"]
+        return self._cfg.get("enable_new_ir")
 
     @enable_new_ir.setter
     def enable_new_ir(self, enable_new_ir: bool):
@@ -211,7 +263,7 @@ class PaddlePredictorOption(object):
 
     @property
     def enable_cinn(self):
-        return self._cfg["enable_cinn"]
+        return self._cfg.get("enable_cinn")
 
     @enable_cinn.setter
     def enable_cinn(self, enable_cinn: bool):
@@ -220,7 +272,7 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_cfg_setting(self):
-        return self._cfg["trt_cfg_setting"]
+        return self._cfg.get("trt_cfg_setting")
 
     @trt_cfg_setting.setter
     def trt_cfg_setting(self, config: Dict):
@@ -232,7 +284,7 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_use_dynamic_shapes(self):
-        return self._cfg["trt_use_dynamic_shapes"]
+        return self._cfg.get("trt_use_dynamic_shapes")
 
     @trt_use_dynamic_shapes.setter
     def trt_use_dynamic_shapes(self, trt_use_dynamic_shapes):
@@ -240,7 +292,7 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_collect_shape_range_info(self):
-        return self._cfg["trt_collect_shape_range_info"]
+        return self._cfg.get("trt_collect_shape_range_info")
 
     @trt_collect_shape_range_info.setter
     def trt_collect_shape_range_info(self, trt_collect_shape_range_info):
@@ -248,7 +300,7 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_discard_cached_shape_range_info(self):
-        return self._cfg["trt_discard_cached_shape_range_info"]
+        return self._cfg.get("trt_discard_cached_shape_range_info")
 
     @trt_discard_cached_shape_range_info.setter
     def trt_discard_cached_shape_range_info(self, trt_discard_cached_shape_range_info):
@@ -258,7 +310,7 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_dynamic_shapes(self):
-        return self._cfg["trt_dynamic_shapes"]
+        return self._cfg.get("trt_dynamic_shapes")
 
     @trt_dynamic_shapes.setter
     def trt_dynamic_shapes(self, trt_dynamic_shapes: Dict[str, List[List[int]]]):
@@ -269,7 +321,7 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_dynamic_shape_input_data(self):
-        return self._cfg["trt_dynamic_shape_input_data"]
+        return self._cfg.get("trt_dynamic_shape_input_data")
 
     @trt_dynamic_shape_input_data.setter
     def trt_dynamic_shape_input_data(
@@ -279,7 +331,7 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_shape_range_info_path(self):
-        return self._cfg["trt_shape_range_info_path"]
+        return self._cfg.get("trt_shape_range_info_path")
 
     @trt_shape_range_info_path.setter
     def trt_shape_range_info_path(self, trt_shape_range_info_path: str):
@@ -288,12 +340,20 @@ class PaddlePredictorOption(object):
 
     @property
     def trt_allow_rebuild_at_runtime(self):
-        return self._cfg["trt_allow_rebuild_at_runtime"]
+        return self._cfg.get("trt_allow_rebuild_at_runtime")
 
     @trt_allow_rebuild_at_runtime.setter
     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.get("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/download.py

@@ -39,14 +39,14 @@ class _ProgressPrinter(object):
             str_ += "\n"
             self._last_time = 0
         if time.time() - self._last_time >= self._flush_intvl:
-            sys.stdout.write(f"\r{str_}")
+            sys.stderr.write(f"\r{str_}")
             self._last_time = time.time()
-            sys.stdout.flush()
+            sys.stderr.flush()
 
 
 def _download(url, save_path, print_progress):
     if print_progress:
-        print(f"Connecting to {url} ...")
+        print(f"Connecting to {url} ...", file=sys.stderr)
 
     with requests.get(url, stream=True, timeout=15) as r:
         r.raise_for_status()
@@ -62,7 +62,10 @@ def _download(url, save_path, print_progress):
                 total_length = int(total_length)
                 if print_progress:
                     printer = _ProgressPrinter()
-                    print(f"Downloading {os.path.basename(save_path)} ...")
+                    print(
+                        f"Downloading {os.path.basename(save_path)} ...",
+                        file=sys.stderr,
+                    )
                 for data in r.iter_content(chunk_size=4096):
                     dl += len(data)
                     f.write(data)
@@ -95,17 +98,17 @@ def _extract_tar_file(file_path, extd_dir):
                 try:
                     f.extract(file, extd_dir)
                 except KeyError:
-                    print(f"File {file} not found in the archive.")
+                    print(f"File {file} not found in the archive.", file=sys.stderr)
                 yield total_num, index
     except Exception as e:
-        print(f"An error occurred: {e}")
+        print(f"An error occurred: {e}", file=sys.stderr)
 
 
 def _extract(file_path, extd_dir, print_progress):
     """extract"""
     if print_progress:
         printer = _ProgressPrinter()
-        print(f"Extracting {os.path.basename(file_path)}")
+        print(f"Extracting {os.path.basename(file_path)}", file=sys.stderr)
 
     if zipfile.is_zipfile(file_path):
         handler = _extract_zip_file

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]