paddlex 3.0.0rc0__py3-none-any.whl → 3.0.1__py3-none-any.whl

paddlex/ops/iou3d_nms/iou3d_nms_kernel.cu

@@ -69,7 +69,7 @@ __device__ inline int check_in_box2d(const float *box, const Point &p) {
   float center_x = box[0], center_y = box[1];
   float angle_cos = cos(-box[6]),
         angle_sin =
-            sin(-box[6]);  // rotate the point in the opposite direction of box
+            sin(-box[6]); // rotate the point in the opposite direction of box
   float rot_x = (p.x - center_x) * angle_cos + (p.y - center_y) * (-angle_sin);
   float rot_y = (p.x - center_x) * angle_sin + (p.y - center_y) * angle_cos;
 
@@ -81,7 +81,8 @@ __device__ inline int intersection(const Point &p1, const Point &p0,
                                    const Point &q1, const Point &q0,
                                    Point &ans) {
   // fast exclusion
-  if (check_rect_cross(p0, p1, q0, q1) == 0) return 0;
+  if (check_rect_cross(p0, p1, q0, q1) == 0)
+    return 0;
 
   // check cross standing
   float s1 = cross(q0, p1, p0);
@@ -89,7 +90,8 @@ __device__ inline int intersection(const Point &p1, const Point &p0,
   float s3 = cross(p0, q1, q0);
   float s4 = cross(q1, p1, q0);
 
-  if (!(s1 * s2 > 0 && s3 * s4 > 0)) return 0;
+  if (!(s1 * s2 > 0 && s3 * s4 > 0))
+    return 0;
 
   // calculate intersection of two lines
   float s5 = cross(q1, p1, p0);
@@ -438,13 +440,13 @@ void BoxesOverlapLauncher(const cudaStream_t &stream, const int num_a,
                           const float *boxes_b, float *ans_overlap) {
   dim3 blocks(
       DIVUP(num_b, THREADS_PER_BLOCK),
-      DIVUP(num_a, THREADS_PER_BLOCK));  // blockIdx.x(col), blockIdx.y(row)
+      DIVUP(num_a, THREADS_PER_BLOCK)); // blockIdx.x(col), blockIdx.y(row)
   dim3 threads(THREADS_PER_BLOCK, THREADS_PER_BLOCK);
 
   boxes_overlap_kernel<<<blocks, threads, 0, stream>>>(num_a, boxes_a, num_b,
                                                        boxes_b, ans_overlap);
 #ifdef DEBUG
-  cudaDeviceSynchronize();  // for using printf in kernel function
+  cudaDeviceSynchronize(); // for using printf in kernel function
 #endif
 }
 
@@ -453,13 +455,13 @@ void BoxesIouBevLauncher(const cudaStream_t &stream, const int num_a,
                          const float *boxes_b, float *ans_iou) {
   dim3 blocks(
       DIVUP(num_b, THREADS_PER_BLOCK),
-      DIVUP(num_a, THREADS_PER_BLOCK));  // blockIdx.x(col), blockIdx.y(row)
+      DIVUP(num_a, THREADS_PER_BLOCK)); // blockIdx.x(col), blockIdx.y(row)
   dim3 threads(THREADS_PER_BLOCK, THREADS_PER_BLOCK);
 
   boxes_iou_bev_kernel<<<blocks, threads, 0, stream>>>(num_a, boxes_a, num_b,
                                                        boxes_b, ans_iou);
 #ifdef DEBUG
-  cudaDeviceSynchronize();  // for using printf in kernel function
+  cudaDeviceSynchronize(); // for using printf in kernel function
 #endif
 }
 

paddlex/ops/setup.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,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import lazy_paddle as paddle
-from lazy_paddle.utils.cpp_extension import CppExtension, CUDAExtension, setup
+import paddle
+from paddle.utils.cpp_extension import CppExtension, CUDAExtension, setup
 
 from paddlex.ops import custom_ops
 

paddlex/ops/voxel/voxelize_op.cc

@@ -81,10 +81,11 @@ bool hard_voxelize_cpu_kernel(
   return true;
 }
 
-std::vector<paddle::Tensor> hard_voxelize_cpu(
-    const paddle::Tensor &points, const std::vector<float> &voxel_size,
-    const std::vector<float> &point_cloud_range,
-    const int max_num_points_in_voxel, const int max_voxels) {
+std::vector<paddle::Tensor>
+hard_voxelize_cpu(const paddle::Tensor &points,
+                  const std::vector<float> &voxel_size,
+                  const std::vector<float> &point_cloud_range,
+                  const int max_num_points_in_voxel, const int max_voxels) {
   auto num_points = points.shape()[0];
   auto num_point_dim = points.shape()[1];
 
@@ -140,16 +141,18 @@ std::vector<paddle::Tensor> hard_voxelize_cpu(
 }
 
 #ifdef PADDLE_WITH_CUDA
-std::vector<paddle::Tensor> hard_voxelize_cuda(
-    const paddle::Tensor &points, const std::vector<float> &voxel_size,
-    const std::vector<float> &point_cloud_range, int max_num_points_in_voxel,
-    int max_voxels);
+std::vector<paddle::Tensor>
+hard_voxelize_cuda(const paddle::Tensor &points,
+                   const std::vector<float> &voxel_size,
+                   const std::vector<float> &point_cloud_range,
+                   int max_num_points_in_voxel, int max_voxels);
 #endif
 
-std::vector<paddle::Tensor> hard_voxelize(
-    const paddle::Tensor &points, const std::vector<float> &voxel_size,
-    const std::vector<float> &point_cloud_range,
-    const int max_num_points_in_voxel, const int max_voxels) {
+std::vector<paddle::Tensor>
+hard_voxelize(const paddle::Tensor &points,
+              const std::vector<float> &voxel_size,
+              const std::vector<float> &point_cloud_range,
+              const int max_num_points_in_voxel, const int max_voxels) {
   if (points.is_cpu()) {
     return hard_voxelize_cpu(points, voxel_size, point_cloud_range,
                              max_num_points_in_voxel, max_voxels);
@@ -159,16 +162,16 @@ std::vector<paddle::Tensor> hard_voxelize(
                               max_num_points_in_voxel, max_voxels);
 #endif
   } else {
-    PD_THROW(
-        "Unsupported device type for hard_voxelize "
-        "operator.");
+    PD_THROW("Unsupported device type for hard_voxelize "
+             "operator.");
   }
 }
 
-std::vector<std::vector<int64_t>> HardInferShape(
-    std::vector<int64_t> points_shape, const std::vector<float> &voxel_size,
-    const std::vector<float> &point_cloud_range,
-    const int &max_num_points_in_voxel, const int &max_voxels) {
+std::vector<std::vector<int64_t>>
+HardInferShape(std::vector<int64_t> points_shape,
+               const std::vector<float> &voxel_size,
+               const std::vector<float> &point_cloud_range,
+               const int &max_num_points_in_voxel, const int &max_voxels) {
   return {{max_voxels, max_num_points_in_voxel, points_shape[1]},
           {max_voxels, 3},
           {max_voxels},

paddlex/ops/voxel/voxelize_op.cu

@@ -14,11 +14,11 @@
 
 #include "paddle/extension.h"
 
-#define CHECK_INPUT_CUDA(x) \
+#define CHECK_INPUT_CUDA(x)                                                    \
   PD_CHECK(x.is_gpu() || x.is_gpu_pinned(), #x " must be a GPU Tensor.")
 
-#define CUDA_KERNEL_LOOP(i, n)                                  \
-  for (auto i = blockIdx.x * blockDim.x + threadIdx.x; i < (n); \
+#define CUDA_KERNEL_LOOP(i, n)                                                 \
+  for (auto i = blockIdx.x * blockDim.x + threadIdx.x; i < (n);                \
        i += blockDim.x * gridDim.x)
 
 template <typename T, typename T_int>
@@ -119,12 +119,11 @@ __global__ void update_points_flag(const int *points_valid,
 }
 
 template <typename T_int>
-__global__ void get_voxel_idx_kernel(const int *points_flag,
-                                     const T_int *points_to_grid_idx,
-                                     const int *points_flag_prefix_sum,
-                                     const int num_points, const int max_voxels,
-                                     T_int *num_voxels,
-                                     T_int *grid_idx_to_voxel_idx) {
+__global__ void
+get_voxel_idx_kernel(const int *points_flag, const T_int *points_to_grid_idx,
+                     const int *points_flag_prefix_sum, const int num_points,
+                     const int max_voxels, T_int *num_voxels,
+                     T_int *grid_idx_to_voxel_idx) {
   int tid = threadIdx.x + blockIdx.x * blockDim.x;
   for (int i = tid; i < num_points; i += gridDim.x * blockDim.x) {
     if (points_flag[i] == 1) {
@@ -155,11 +154,12 @@ __global__ void init_voxels_kernel(const int64_t num, T *voxels) {
 }
 
 template <typename T, typename T_int>
-__global__ void assign_voxels_kernel(
-    const T *points, const T_int *points_to_grid_idx,
-    const T_int *points_to_num_idx, const T_int *grid_idx_to_voxel_idx,
-    const int64_t num_points, const int num_point_dim,
-    const int max_num_points_in_voxel, T *voxels) {
+__global__ void
+assign_voxels_kernel(const T *points, const T_int *points_to_grid_idx,
+                     const T_int *points_to_num_idx,
+                     const T_int *grid_idx_to_voxel_idx,
+                     const int64_t num_points, const int num_point_dim,
+                     const int max_num_points_in_voxel, T *voxels) {
   int64_t point_idx = blockIdx.x * blockDim.x + threadIdx.x;
   if (point_idx > num_points || point_idx == num_points) {
     return;
@@ -179,13 +179,12 @@ __global__ void assign_voxels_kernel(
 }
 
 template <typename T, typename T_int>
-__global__ void assign_coords_kernel(const T_int *grid_idx_to_voxel_idx,
-                                     const T_int *num_points_in_grid,
-                                     const int num_grids, const int grid_size_x,
-                                     const int grid_size_y,
-                                     const int grid_size_z,
-                                     const int max_num_points_in_voxel,
-                                     T *coords, T *num_points_per_voxel) {
+__global__ void
+assign_coords_kernel(const T_int *grid_idx_to_voxel_idx,
+                     const T_int *num_points_in_grid, const int num_grids,
+                     const int grid_size_x, const int grid_size_y,
+                     const int grid_size_z, const int max_num_points_in_voxel,
+                     T *coords, T *num_points_per_voxel) {
   int64_t grid_idx = blockIdx.x * blockDim.x + threadIdx.x;
   if (grid_idx > num_grids || grid_idx == num_grids) {
     return;
@@ -205,10 +204,11 @@ __global__ void assign_coords_kernel(const T_int *grid_idx_to_voxel_idx,
   }
 }
 
-std::vector<paddle::Tensor> hard_voxelize_cuda(
-    const paddle::Tensor &points, const std::vector<float> &voxel_size,
-    const std::vector<float> &point_cloud_range, int max_num_points_in_voxel,
-    int max_voxels) {
+std::vector<paddle::Tensor>
+hard_voxelize_cuda(const paddle::Tensor &points,
+                   const std::vector<float> &voxel_size,
+                   const std::vector<float> &point_cloud_range,
+                   int max_num_points_in_voxel, int max_voxels) {
   // check device
   CHECK_INPUT_CUDA(points);
 

paddlex/paddlex_cli.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,19 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import ast
 import importlib.resources
+import os
+import shutil
 import subprocess
 import sys
-import shutil
 from pathlib import Path
 
 from . import create_pipeline
+from .constants import MODEL_FILE_PREFIX
 from .inference.pipelines import load_pipeline_config
-from .repo_manager import setup, get_all_supported_repo_names
-from .utils.flags import FLAGS_json_format_model
+from .inference.utils.model_paths import get_model_paths
+from .repo_manager import get_all_supported_repo_names, setup
 from .utils import logging
+from .utils.deps import (
+    get_paddle2onnx_spec,
+    get_serving_dep_specs,
+    require_paddle2onnx_plugin,
+)
+from .utils.env import get_paddle_cuda_version
+from .utils.install import install_packages
 from .utils.interactive_get_pipeline import interactive_get_pipeline
 from .utils.pipeline_arguments import PIPELINE_ARGUMENTS
 
@@ -57,15 +66,9 @@ def args_cfg():
     ################# install pdx #################
     install_group.add_argument(
         "--install",
-        action="store_true",
-        default=False,
-        help="Install specified PaddleX plugins.",
-    )
-    install_group.add_argument(
-        "plugins",
         nargs="*",
-        default=[],
-        help="Names of custom development plugins to install (space-separated).",
+        metavar="PLUGIN",
+        help="Install specified PaddleX plugins.",
     )
     install_group.add_argument(
         "--no_deps",
@@ -92,6 +95,13 @@ def args_cfg():
         default=False,
         help="Use local repositories if they exist.",
     )
+    install_group.add_argument(
+        "--deps_to_replace",
+        type=str,
+        nargs="+",
+        default=None,
+        help="Replace dependency version when installing from repositories.",
+    )
 
     ################# pipeline predict #################
     pipeline_group.add_argument(
@@ -116,7 +126,14 @@ def args_cfg():
         help="Device to run the pipeline on (e.g., 'cpu', 'gpu:0').",
     )
     pipeline_group.add_argument(
-        "--use_hpip", action="store_true", help="Enable HPIP acceleration if available."
+        "--use_hpip",
+        action="store_true",
+        help="Use high-performance inference plugin.",
+    )
+    pipeline_group.add_argument(
+        "--hpi_config",
+        type=ast.literal_eval,
+        help="High-performance inference configuration.",
     )
     pipeline_group.add_argument(
         "--get_pipeline_config",
@@ -143,23 +160,26 @@ def args_cfg():
         default=8080,
         help="Port number to serve on (default: 8080).",
     )
-    # Serving also uses `--pipeline`, `--device`, and `--use_hpip`
+    # Serving also uses `--pipeline`, `--device`, `--use_hpip`, and `--hpi_config`
 
     ################# paddle2onnx #################
     paddle2onnx_group.add_argument(
-        "--paddle2onnx", action="store_true", help="Convert Paddle model to ONNX format"
+        "--paddle2onnx",
+        action="store_true",
+        help="Convert PaddlePaddle model to ONNX format.",
     )
     paddle2onnx_group.add_argument(
-        "--paddle_model_dir", type=str, help="Directory containing the Paddle model"
+        "--paddle_model_dir",
+        type=str,
+        help="Directory containing the PaddlePaddle model.",
     )
     paddle2onnx_group.add_argument(
         "--onnx_model_dir",
         type=str,
-        default="onnx",
-        help="Output directory for the ONNX model",
+        help="Output directory for the ONNX model.",
     )
     paddle2onnx_group.add_argument(
-        "--opset_version", type=int, help="Version of the ONNX opset to use"
+        "--opset_version", type=int, default=7, help="Version of the ONNX opset to use."
     )
 
     # Parse known arguments to get the pipeline name
@@ -167,7 +187,10 @@ def args_cfg():
     pipeline = args.pipeline
     pipeline_args = []
 
-    if not (args.install or args.serve or args.paddle2onnx) and pipeline is not None:
+    if (
+        not (args.install is not None or args.serve or args.paddle2onnx)
+        and pipeline is not None
+    ):
         if os.path.isfile(pipeline):
             pipeline_name = load_pipeline_config(pipeline)["pipeline_name"]
         else:
@@ -200,57 +223,49 @@ def install(args):
     """install paddlex"""
 
     def _install_serving_deps():
-        with importlib.resources.path(
-            "paddlex", "serving_requirements.txt"
-        ) as req_file:
-            return subprocess.check_call(
-                [sys.executable, "-m", "pip", "install", "-r", str(req_file)]
-            )
+        reqs = get_serving_dep_specs()
+        # Should we sort the requirements?
+        install_packages(reqs)
 
     def _install_paddle2onnx_deps():
-        with importlib.resources.path(
-            "paddlex", "paddle2onnx_requirements.txt"
-        ) as req_file:
-            return subprocess.check_call(
-                [sys.executable, "-m", "pip", "install", "-r", str(req_file)]
-            )
+        install_packages([get_paddle2onnx_spec()])
 
     def _install_hpi_deps(device_type):
-        support_device_type = ["cpu", "gpu"]
-        if device_type not in support_device_type:
+        SUPPORTED_DEVICE_TYPES = ["cpu", "gpu", "npu"]
+        if device_type not in SUPPORTED_DEVICE_TYPES:
             logging.error(
-                "HPI installation failed!\n"
-                "Supported device_type: %s. Your input device_type: %s.\n"
-                "Please ensure the device_type is correct.",
-                support_device_type,
+                "Failed to install the high-performance plugin.\n"
+                "Supported device types: %s. Your input device type: %s.\n",
+                SUPPORTED_DEVICE_TYPES,
                 device_type,
             )
             sys.exit(2)
 
         if device_type == "cpu":
-            packages = ["ultra-infer-python", "paddlex-hpi"]
+            package = "ultra-infer-python"
         elif device_type == "gpu":
-            packages = ["ultra-infer-gpu-python", "paddlex-hpi"]
+            cuda_version = get_paddle_cuda_version()
+            if not cuda_version:
+                sys.exit(
+                    "No CUDA version found. Please make sure you have installed PaddlePaddle with CUDA enabled."
+                )
+            if cuda_version[0] != 11:
+                sys.exit(
+                    "You are not using PaddlePaddle compiled with CUDA 11. Currently, CUDA versions other than 11.x are not supported by the high-performance inference plugin."
+                )
+            package = "ultra-infer-gpu-python"
+        elif device_type == "npu":
+            package = "ultra-infer-npu-python"
 
         with importlib.resources.path("paddlex", "hpip_links.html") as f:
-            return subprocess.check_call(
-                [
-                    sys.executable,
-                    "-m",
-                    "pip",
-                    "install",
-                    "--find-links",
-                    str(f),
-                    *packages,
-                ]
-            )
+            install_packages([package], pip_install_opts=["--find-links", str(f)])
 
     # Enable debug info
     os.environ["PADDLE_PDX_DEBUG"] = "True"
     # Disable eager initialization
     os.environ["PADDLE_PDX_EAGER_INIT"] = "False"
 
-    plugins = args.plugins[:]
+    plugins = args.install[:]
 
     if "serving" in plugins:
         plugins.remove("serving")
@@ -296,6 +311,7 @@ def install(args):
         platform=args.platform,
         update_repos=args.update_repos,
         use_local_repos=args.use_local_repos,
+        deps_to_replace=args.deps_to_replace,
     )
     return
 
@@ -306,10 +322,13 @@ def pipeline_predict(
     device,
     save_path,
     use_hpip,
+    hpi_config,
     **pipeline_args,
 ):
     """pipeline predict"""
-    pipeline = create_pipeline(pipeline, device=device, use_hpip=use_hpip)
+    pipeline = create_pipeline(
+        pipeline, device=device, use_hpip=use_hpip, hpi_config=hpi_config
+    )
     result = pipeline.predict(input, **pipeline_args)
     for res in result:
         res.print()
@@ -317,36 +336,35 @@ def pipeline_predict(
             res.save_all(save_path=save_path)
 
 
-def serve(pipeline, *, device, use_hpip, host, port):
+def serve(pipeline, *, device, use_hpip, hpi_config, host, port):
     from .inference.serving.basic_serving import create_pipeline_app, run_server
 
     pipeline_config = load_pipeline_config(pipeline)
-    pipeline = create_pipeline(config=pipeline_config, device=device, use_hpip=use_hpip)
+    pipeline = create_pipeline(
+        config=pipeline_config, device=device, use_hpip=use_hpip, hpi_config=hpi_config
+    )
     app = create_pipeline_app(pipeline, pipeline_config)
     run_server(app, host=host, port=port)
 
 
 # TODO: Move to another module
 def paddle_to_onnx(paddle_model_dir, onnx_model_dir, *, opset_version):
-    PD_MODEL_FILE_PREFIX = "inference"
-    PD_PARAMS_FILENAME = "inference.pdiparams"
-    ONNX_MODEL_FILENAME = "inference.onnx"
-    CONFIG_FILENAME = "inference.yml"
+    require_paddle2onnx_plugin()
+
+    ONNX_MODEL_FILENAME = f"{MODEL_FILE_PREFIX}.onnx"
+    CONFIG_FILENAME = f"{MODEL_FILE_PREFIX}.yml"
     ADDITIONAL_FILENAMES = ["scaler.pkl"]
 
-    def _check_input_dir(input_dir, pd_model_file_ext):
+    def _check_input_dir(input_dir):
         if input_dir is None:
             sys.exit("Input directory must be specified")
         if not input_dir.exists():
             sys.exit(f"{input_dir} does not exist")
         if not input_dir.is_dir():
             sys.exit(f"{input_dir} is not a directory")
-        model_path = (input_dir / PD_MODEL_FILE_PREFIX).with_suffix(pd_model_file_ext)
-        if not model_path.exists():
-            sys.exit(f"{model_path} does not exist")
-        params_path = input_dir / PD_PARAMS_FILENAME
-        if not params_path.exists():
-            sys.exit(f"{params_path} does not exist")
+        model_paths = get_model_paths(input_dir)
+        if "paddle" not in model_paths:
+            sys.exit("PaddlePaddle model does not exist")
         config_path = input_dir / CONFIG_FILENAME
         if not config_path.exists():
             sys.exit(f"{config_path} does not exist")
@@ -355,23 +373,18 @@ def paddle_to_onnx(paddle_model_dir, onnx_model_dir, *, opset_version):
         if shutil.which("paddle2onnx") is None:
             sys.exit("Paddle2ONNX is not available. Please install the plugin first.")
 
-    def _run_paddle2onnx(input_dir, pd_model_file_ext, output_dir, opset_version):
+    def _run_paddle2onnx(input_dir, output_dir, opset_version):
+        model_paths = get_model_paths(input_dir)
         logging.info("Paddle2ONNX conversion starting...")
         # XXX: To circumvent Paddle2ONNX's bug
-        if opset_version is None:
-            if pd_model_file_ext == ".json":
-                opset_version = 19
-            else:
-                opset_version = 7
-            logging.info("Using default ONNX opset version: %d", opset_version)
         cmd = [
             "paddle2onnx",
             "--model_dir",
-            str(input_dir),
+            str(model_paths["paddle"][0].parent),
             "--model_filename",
-            str(Path(PD_MODEL_FILE_PREFIX).with_suffix(pd_model_file_ext)),
+            str(model_paths["paddle"][0].name),
             "--params_filename",
-            PD_PARAMS_FILENAME,
+            str(model_paths["paddle"][1].name),
             "--save_file",
             str(output_dir / ONNX_MODEL_FILENAME),
             "--opset_version",
@@ -399,16 +412,14 @@ def paddle_to_onnx(paddle_model_dir, onnx_model_dir, *, opset_version):
             logging.info(f"Copied {src_path} to {dst_path}")
 
     paddle_model_dir = Path(paddle_model_dir)
+    if not onnx_model_dir:
+        onnx_model_dir = paddle_model_dir
     onnx_model_dir = Path(onnx_model_dir)
     logging.info(f"Input dir: {paddle_model_dir}")
     logging.info(f"Output dir: {onnx_model_dir}")
-    pd_model_file_ext = ".json"
-    if not FLAGS_json_format_model:
-        if not (paddle_model_dir / f"{PD_MODEL_FILE_PREFIX}.json").exists():
-            pd_model_file_ext = ".pdmodel"
-    _check_input_dir(paddle_model_dir, pd_model_file_ext)
+    _check_input_dir(paddle_model_dir)
     _check_paddle2onnx()
-    _run_paddle2onnx(paddle_model_dir, pd_model_file_ext, onnx_model_dir, opset_version)
+    _run_paddle2onnx(paddle_model_dir, onnx_model_dir, opset_version)
     if not (onnx_model_dir.exists() and onnx_model_dir.samefile(paddle_model_dir)):
         _copy_config_file(paddle_model_dir, onnx_model_dir)
         _copy_additional_files(paddle_model_dir, onnx_model_dir)
@@ -426,22 +437,26 @@ def main():
         parser.print_help()
         sys.exit(2)
 
-    if args.install:
+    if args.install is not None:
         install(args)
+        return
     elif args.serve:
         serve(
             args.pipeline,
             device=args.device,
-            use_hpip=args.use_hpip,
+            use_hpip=args.use_hpip or None,
+            hpi_config=args.hpi_config,
             host=args.host,
             port=args.port,
         )
+        return
     elif args.paddle2onnx:
         paddle_to_onnx(
             args.paddle_model_dir,
             args.onnx_model_dir,
             opset_version=args.opset_version,
         )
+        return
     else:
         if args.get_pipeline_config is not None:
             interactive_get_pipeline(args.get_pipeline_config, args.save_path)
@@ -454,11 +469,13 @@ def main():
                     pipeline_args_dict[arg_name] = getattr(args, arg_name)
                 else:
                     logging.warning(f"Argument {arg_name} is missing in args")
-            return pipeline_predict(
+            pipeline_predict(
                 args.pipeline,
                 args.input,
                 args.device,
                 args.save_path,
-                use_hpip=args.use_hpip,
+                use_hpip=args.use_hpip or None,
+                hpi_config=args.hpi_config,
                 **pipeline_args_dict,
             )
+            return

paddlex/repo_apis/Paddle3D_api/__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/repo_apis/Paddle3D_api/bev_fusion/__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/repo_apis/Paddle3D_api/bev_fusion/config.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/repo_apis/Paddle3D_api/bev_fusion/model.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,11 +15,11 @@
 
 import os.path as osp
 
-from .runner import raise_unsupported_api_error
-from ...base import BaseModel
 from ....utils import logging
-from ...base.utils.arg import CLIArgument
 from ....utils.misc import abspath
+from ...base import BaseModel
+from ...base.utils.arg import CLIArgument
+from .runner import raise_unsupported_api_error
 
 
 class BEVFusionModel(BaseModel):
@@ -54,7 +54,7 @@ class BEVFusionModel(BaseModel):
             raise ValueError(f"`dy2st`={dy2st} is not supported.")
         if device in ("cpu", "gpu"):
             logging.warning(
-                f"The device type to use will be automatically determined, which may differ from the sepcified type: {repr(device)}."
+                f"The device type to use will be automatically determined, which may differ from the specified type: {repr(device)}."
             )
 
         # Update YAML config file
@@ -134,7 +134,7 @@ class BEVFusionModel(BaseModel):
 
         if device in ("cpu", "gpu"):
             logging.warning(
-                f"The device type to use will be automatically determined, which may differ from the sepcified type: {repr(device)}."
+                f"The device type to use will be automatically determined, which may differ from the specified type: {repr(device)}."
             )
 
         # Update YAML config file