paddlex 3.0.0b2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

paddlex/utils/device.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -13,16 +13,26 @@
 # limitations under the License.
 
 import os
+from contextlib import ContextDecorator
+
 import GPUtil
-import lazy_paddle as paddle
 
 from . import logging
-from .errors import raise_unsupported_device_error
+from .custom_device_list import (
+    DCU_WHITELIST,
+    GCU_WHITELIST,
+    MLU_WHITELIST,
+    NPU_BLACKLIST,
+    XPU_WHITELIST,
+)
+from .flags import DISABLE_DEV_MODEL_WL
 
-SUPPORTED_DEVICE_TYPE = ["cpu", "gpu", "xpu", "npu", "mlu"]
+SUPPORTED_DEVICE_TYPE = ["cpu", "gpu", "xpu", "npu", "mlu", "gcu", "dcu"]
 
 
-def _constr_device(device_type, device_ids):
+def constr_device(device_type, device_ids):
+    if device_type == "cpu" and device_ids is not None:
+        raise ValueError("`device_ids` must be None for CPUs")
     if device_ids:
         device_ids = ",".join(map(str, device_ids))
         return f"{device_type}:{device_ids}"
@@ -32,10 +42,17 @@ def _constr_device(device_type, device_ids):
 
 def get_default_device():
     avail_gpus = GPUtil.getAvailable()
+    if not avail_gpus:
+        # maybe edge devices like Jetson
+        if os.path.exists("/etc/nv_tegra_release"):
+            avail_gpus = [0]
+            logging.info(
+                "Detected that the current device is a Jetson edge device. The default behavior will be to use GPU: 0"
+            )
     if not avail_gpus:
         return "cpu"
     else:
-        return _constr_device("gpu", [avail_gpus[0]])
+        return constr_device("gpu", [avail_gpus[0]])
 
 
 def parse_device(device):
@@ -58,6 +75,8 @@ def parse_device(device):
     device_type = device_type.lower()
     # raise_unsupported_device_error(device_type, SUPPORTED_DEVICE_TYPE)
     assert device_type.lower() in SUPPORTED_DEVICE_TYPE
+    if device_type == "cpu" and device_ids is not None:
+        raise ValueError("No Device ID should be specified for CPUs")
     return device_type, device_ids
 
 
@@ -65,39 +84,112 @@ def update_device_num(device, num):
     device_type, device_ids = parse_device(device)
     if device_ids:
         assert len(device_ids) >= num
-        return _constr_device(device_type, device_ids[:num])
+        return constr_device(device_type, device_ids[:num])
     else:
-        return _constr_device(device_type, device_ids)
+        return constr_device(device_type, device_ids)
 
 
 def set_env_for_device(device):
+    device_type, _ = parse_device(device)
+    return set_env_for_device_type(device_type)
+
+
+def set_env_for_device_type(device_type):
+    import paddle
+
     def _set(envs):
         for key, val in envs.items():
             os.environ[key] = val
             logging.debug(f"{key} has been set to {val}.")
 
-    device_type, device_ids = parse_device(device)
-    if device_type.lower() in ["gpu", "xpu", "npu", "mlu"]:
-        if device_type.lower() == "gpu" and paddle.is_compiled_with_rocm():
-            envs = {"FLAGS_conv_workspace_size_limit": "2000"}
-            _set(envs)
-        if device_type.lower() == "npu":
-            envs = {
-                "FLAGS_npu_jit_compile": "0",
-                "FLAGS_use_stride_kernel": "0",
-                "FLAGS_allocator_strategy": "auto_growth",
-                "CUSTOM_DEVICE_BLACK_LIST": "pad3d,pad3d_grad,set_value,set_value_with_tensor",
-                "FLAGS_npu_scale_aclnn": "True",
-                "FLAGS_npu_split_aclnn": "True",
-            }
-            _set(envs)
-        if device_type.lower() == "xpu":
-            envs = {
-                "BKCL_FORCE_SYNC": "1",
-                "BKCL_TIMEOUT": "1800",
-                "FLAGS_use_stride_kernel": "0",
-            }
-            _set(envs)
-        if device_type.lower() == "mlu":
-            envs = {"FLAGS_use_stride_kernel": "0"}
-            _set(envs)
+    # XXX: is_compiled_with_rocm() must be True on dcu platform ?
+    if device_type.lower() == "dcu" and paddle.is_compiled_with_rocm():
+        envs = {"FLAGS_conv_workspace_size_limit": "2000"}
+        _set(envs)
+    if device_type.lower() == "npu":
+        envs = {
+            "FLAGS_npu_jit_compile": "0",
+            "FLAGS_use_stride_kernel": "0",
+            "FLAGS_allocator_strategy": "auto_growth",
+            "CUSTOM_DEVICE_BLACK_LIST": "pad3d,pad3d_grad,set_value,set_value_with_tensor",
+            "FLAGS_npu_scale_aclnn": "True",
+            "FLAGS_npu_split_aclnn": "True",
+        }
+        _set(envs)
+    if device_type.lower() == "xpu":
+        envs = {
+            "BKCL_FORCE_SYNC": "1",
+            "BKCL_TIMEOUT": "1800",
+            "FLAGS_use_stride_kernel": "0",
+            "XPU_BLACK_LIST": "pad3d",
+        }
+        _set(envs)
+    if device_type.lower() == "mlu":
+        envs = {"FLAGS_use_stride_kernel": "0"}
+        _set(envs)
+    if device_type.lower() == "gcu":
+        envs = {"FLAGS_use_stride_kernel": "0"}
+        _set(envs)
+
+
+def check_supported_device_type(device_type, model_name):
+    if DISABLE_DEV_MODEL_WL:
+        logging.warning(
+            "Skip checking if model is supported on device because the flag `PADDLE_PDX_DISABLE_DEV_MODEL_WL` has been set."
+        )
+        return
+    tips = "You could set env `PADDLE_PDX_DISABLE_DEV_MODEL_WL` to `true` to disable this checking."
+    if device_type == "dcu":
+        assert model_name in DCU_WHITELIST, (
+            f"The DCU device does not yet support `{model_name}` model!" + tips
+        )
+    elif device_type == "mlu":
+        assert model_name in MLU_WHITELIST, (
+            f"The MLU device does not yet support `{model_name}` model!" + tips
+        )
+    elif device_type == "npu":
+        assert model_name not in NPU_BLACKLIST, (
+            f"The NPU device does not yet support `{model_name}` model!" + tips
+        )
+    elif device_type == "xpu":
+        assert model_name in XPU_WHITELIST, (
+            f"The XPU device does not yet support `{model_name}` model!" + tips
+        )
+    elif device_type == "gcu":
+        assert model_name in GCU_WHITELIST, (
+            f"The GCU device does not yet support `{model_name}` model!" + tips
+        )
+
+
+def check_supported_device(device, model_name):
+    device_type, _ = parse_device(device)
+    return check_supported_device_type(device_type, model_name)
+
+
+class TemporaryDeviceChanger(ContextDecorator):
+    """
+    A context manager to temporarily change global device
+    """
+
+    def __init__(self, new_device):
+        # if new_device is None, nothing changed
+        import paddle
+
+        self.new_device = new_device
+        self.original_device = paddle.device.get_device()
+
+    def __enter__(self):
+        import paddle
+
+        if self.new_device is None:
+            return self
+        paddle.device.set_device(self.new_device)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        import paddle
+
+        if self.new_device is None:
+            return False
+        paddle.device.set_device(self.original_device)
+        return False

paddlex/utils/download.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -13,12 +13,12 @@
 # limitations under the License.
 
 import os
-import sys
-import time
 import shutil
+import sys
 import tarfile
-import zipfile
 import tempfile
+import time
+import zipfile
 
 import requests
 

paddlex/utils/env.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2024 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 get_device_type():
+    import paddle
+
+    device_str = paddle.get_device()
+    return device_str.split(":")[0]
+
+
+def get_paddle_version():
+    import paddle
+
+    version = paddle.__version__
+    if "-" in version:
+        version, tag = version.split("-")
+    else:
+        tag = None
+    version = version.split(".")
+    assert len(version) == 3
+    major_v, minor_v, patch_v = map(int, version)
+    if tag:
+        return major_v, minor_v, patch_v, tag
+    else:
+        return major_v, minor_v, patch_v, None
+
+
+def get_paddle_cuda_version():
+    import paddle.version
+
+    cuda_version = paddle.version.cuda()
+    return tuple(map(int, cuda_version.split(".")))
+
+
+def get_paddle_cudnn_version():
+    import paddle.version
+
+    cudnn_version = paddle.version.cudnn()
+    return tuple(map(int, cudnn_version.split(".")))
+
+
+# Should we also support getting the runtime versions of CUDA and cuDNN?

paddlex/utils/errors/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.

paddlex/utils/errors/dataset_checker.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.

paddlex/utils/errors/others.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -14,8 +14,8 @@
 
 import json
 import signal
-from typing import Union
 from pathlib import Path
+from typing import Union
 
 __all__ = [
     "UnsupportedAPIError",
@@ -34,38 +34,26 @@ __all__ = [
 class UnsupportedAPIError(Exception):
     """UnsupportedAPIError"""
 
-    pass
-
 
 class UnsupportedParamError(Exception):
     """UnsupportedParamError"""
 
-    pass
-
 
 class KeyNotFoundError(Exception):
     """KeyNotFoundError"""
 
-    pass
-
 
 class ClassNotFoundException(Exception):
     """ClassNotFoundException"""
 
-    pass
-
 
 class NoEntityRegisteredException(Exception):
     """NoEntityRegisteredException"""
 
-    pass
-
 
 class UnsupportedDeviceError(Exception):
     """UnsupportedDeviceError"""
 
-    pass
-
 
 class CalledProcessError(Exception):
     """CalledProcessError"""
@@ -90,8 +78,6 @@ class CalledProcessError(Exception):
 class DuplicateRegistrationError(Exception):
     """DuplicateRegistrationError"""
 
-    pass
-
 
 class ModelNotFoundError(Exception):
     """Model Not Found Error"""

paddlex/utils/file_interface.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -15,12 +15,11 @@
 
 import logging
 import os
-from threading import ThreadError
 
-from filelock import FileLock
-import yaml
-import ruamel.yaml
 import chardet
+import ruamel.yaml
+import yaml
+from filelock import FileLock
 
 try:
     import ujson as json

paddlex/utils/flags.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -21,11 +21,14 @@ __all__ = [
     "CHECK_OPTS",
     "EAGER_INITIALIZATION",
     "INFER_BENCHMARK",
-    "INFER_BENCHMARK_ITER",
+    "INFER_BENCHMARK_ITERS",
     "INFER_BENCHMARK_WARMUP",
-    "INFER_BENCHMARK_OUTPUT",
-    "INFER_BENCHMARK_DATA_SIZE",
+    "INFER_BENCHMARK_OUTPUT_DIR",
+    "INFER_BENCHMARK_USE_NEW_INFER_API",
     "FLAGS_json_format_model",
+    "USE_PIR_TRT",
+    "DISABLE_DEV_MODEL_WL",
+    "DISABLE_CINN_MODEL_WL",
 ]
 
 
@@ -45,17 +48,25 @@ DEBUG = get_flag_from_env_var("PADDLE_PDX_DEBUG", False)
 DRY_RUN = get_flag_from_env_var("PADDLE_PDX_DRY_RUN", False)
 CHECK_OPTS = get_flag_from_env_var("PADDLE_PDX_CHECK_OPTS", False)
 EAGER_INITIALIZATION = get_flag_from_env_var("PADDLE_PDX_EAGER_INIT", True)
-FLAGS_json_format_model = get_flag_from_env_var("FLAGS_json_format_model", None)
+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)
 
 # Inference Benchmark
-INFER_BENCHMARK = get_flag_from_env_var("PADDLE_PDX_INFER_BENCHMARK", None)
+INFER_BENCHMARK = get_flag_from_env_var("PADDLE_PDX_INFER_BENCHMARK", False)
 INFER_BENCHMARK_WARMUP = get_flag_from_env_var(
     "PADDLE_PDX_INFER_BENCHMARK_WARMUP", 0, int
 )
-INFER_BENCHMARK_OUTPUT = get_flag_from_env_var(
-    "PADDLE_PDX_INFER_BENCHMARK_OUTPUT", None
+INFER_BENCHMARK_OUTPUT_DIR = get_flag_from_env_var(
+    "PADDLE_PDX_INFER_BENCHMARK_OUTPUT_DIR", None
 )
-INFER_BENCHMARK_ITER = get_flag_from_env_var("PADDLE_PDX_INFER_BENCHMARK_ITER", 10, int)
-INFER_BENCHMARK_DATA_SIZE = get_flag_from_env_var(
-    "PADDLE_PDX_INFER_BENCHMARK_DATA_SIZE", 1024
+INFER_BENCHMARK_ITERS = get_flag_from_env_var(
+    "PADDLE_PDX_INFER_BENCHMARK_ITERS", 0, int
+)
+INFER_BENCHMARK_USE_CACHE_FOR_READ = get_flag_from_env_var(
+    "PADDLE_PDX_INFER_BENCHMARK_USE_CACHE_FOR_READ", False
+)
+INFER_BENCHMARK_USE_NEW_INFER_API = get_flag_from_env_var(
+    "PADDLE_PDX_INFER_BENCHMARK_USE_NEW_INFER_API", False
 )

paddlex/utils/fonts/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -12,13 +12,57 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 from pathlib import Path
 
+import PIL
+from PIL import ImageFont
+
+from .. import logging
+from ..download import download
+
+
+def get_font_file_path(file_name: str) -> str:
+    """
+    Get the path of the font file.
+
+    Returns:
+    str: The path to the font file.
+    """
+    font_path = (Path(__file__).parent / file_name).resolve().as_posix()
+    if not Path(font_path).exists():
+        download(
+            url=f"https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/fonts/{file_name}",
+            save_path=font_path,
+        )
+
+    return font_path
+
+
+def create_font(txt: str, sz: tuple, font_path: str) -> ImageFont:
+    """
+    Create a font object with specified size and path, adjusted to fit within the given image region.
+
+    Parameters:
+    txt (str): The text to be rendered with the font.
+    sz (tuple): A tuple containing the height and width of an image region, used for font size.
+    font_path (str): The path to the font file.
+
+    Returns:
+    ImageFont: An ImageFont object adjusted to fit within the given image region.
+    """
+
+    font_size = int(sz[1] * 0.8)
+    font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
+    if int(PIL.__version__.split(".")[0]) < 10:
+        length = font.getsize(txt)[0]
+    else:
+        length = font.getlength(txt)
 
-def get_pingfang_file_path():
-    """get pingfang font file path"""
-    return (Path(__file__).parent / "PingFang-SC-Regular.ttf").resolve().as_posix()
+    if length > sz[0]:
+        font_size = int(font_size * sz[0] / length)
+        font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
+    return font
 
 
-PINGFANG_FONT_FILE_PATH = get_pingfang_file_path()
+PINGFANG_FONT_FILE_PATH = get_font_file_path("PingFang-SC-Regular.ttf")
+SIMFANG_FONT_FILE_PATH = get_font_file_path("simfang.ttf")

paddlex/utils/func_register.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.

paddlex/utils/install.py

@@ -0,0 +1,87 @@
+# Copyright (c) 2024 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.
+
+import os
+import subprocess
+import sys
+import tempfile
+
+from packaging.requirements import Requirement
+
+from . import logging
+
+
+def install_packages_from_requirements_file(
+    requirements_file_path, pip_install_opts=None
+):
+    from .deps import DEP_SPECS
+
+    # TODO: Precompute or cache the constraints
+    with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
+        for reqs in DEP_SPECS.values():
+            for req in reqs:
+                req = Requirement(req)
+                if req.marker and not req.marker.evaluate():
+                    continue
+                if req.url:
+                    req = f"{req.name}@{req.url}"
+                else:
+                    req = f"{req.name}{req.specifier}"
+                f.write(req + "\n")
+        constraints_file_path = f.name
+
+    args = [
+        sys.executable,
+        "-m",
+        "pip",
+        "install",
+        "-c",
+        constraints_file_path,
+        *(pip_install_opts or []),
+        "-r",
+        requirements_file_path,
+    ]
+    logging.debug("Command: %s", args)
+
+    try:
+        return subprocess.check_call(args)
+    finally:
+        os.unlink(constraints_file_path)
+
+
+def install_packages(requirements, pip_install_opts=None):
+    with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
+        for req in requirements:
+            f.write(req + "\n")
+        reqs_file_path = f.name
+    try:
+        return install_packages_from_requirements_file(
+            reqs_file_path, pip_install_opts=pip_install_opts
+        )
+    finally:
+        os.unlink(reqs_file_path)
+
+
+def uninstall_packages(packages, pip_uninstall_opts=None):
+    args = [
+        sys.executable,
+        "-m",
+        "pip",
+        "uninstall",
+        "-y",
+        *(pip_uninstall_opts or []),
+        *packages,
+    ]
+    logging.debug("Command: %s", args)
+    return subprocess.check_call(args)

paddlex/utils/interactive_get_pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pathlib import Path
 import shutil
+from pathlib import Path
 
-from ..utils import logging
 from ..inference.utils.get_pipeline_path import get_pipeline_path
+from ..utils import logging
 
 
 def interactive_get_pipeline(pipeline, save_path):

paddlex/utils/lazy_loader.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -14,8 +14,9 @@
 
 # Code copied from https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/util/lazy_loader.py
 import importlib
-import types
+import inspect
 import os
+import types
 
 from . import logging
 from .flags import FLAGS_json_format_model
@@ -52,6 +53,7 @@ class LazyLoader(types.ModuleType):
         self._module = module
 
     def __getattr__(self, item):
+        logging.debug("lazy load in : %s", inspect.currentframe().f_back)
         if not self.loaded:
             # HACK: For circumventing shared library symbol conflicts when
             # importing paddlex_hpi