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

paddlex/ops/iou3d_nms/iou3d_cpu.cpp

@@ -76,7 +76,7 @@ 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;
 
@@ -87,7 +87,8 @@ inline int check_in_box2d(const float *box, const Point &p) {
 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);
@@ -95,7 +96,8 @@ inline int intersection(const Point &p1, const Point &p0, const Point &q1,
   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);
@@ -238,9 +240,9 @@ inline float iou_bev(const float *box_a, const float *box_b) {
   return s_overlap / fmaxf(sa + sb - s_overlap, EPS);
 }
 
-std::vector<paddle::Tensor> boxes_iou_bev_cpu(
-    const paddle::Tensor &boxes_a_tensor,
-    const paddle::Tensor &boxes_b_tensor) {
+std::vector<paddle::Tensor>
+boxes_iou_bev_cpu(const paddle::Tensor &boxes_a_tensor,
+                  const paddle::Tensor &boxes_b_tensor) {
   // params boxes_a_tensor: (N, 7) [x, y, z, dx, dy, dz, heading]
   // params boxes_b_tensor: (M, 7) [x, y, z, dx, dy, dz, heading]
   // params ans_iou_tensor: (N, M)

paddlex/ops/iou3d_nms/iou3d_cpu.h

@@ -21,7 +21,8 @@
 
 #include <vector>
 
-std::vector<paddle::Tensor> boxes_iou_bev_cpu(
-    const paddle::Tensor& boxes_a_tensor, const paddle::Tensor& boxes_b_tensor);
+std::vector<paddle::Tensor>
+boxes_iou_bev_cpu(const paddle::Tensor &boxes_a_tensor,
+                  const paddle::Tensor &boxes_b_tensor);
 
 #endif

paddlex/ops/iou3d_nms/iou3d_nms.cpp

@@ -41,8 +41,9 @@ void NmsLauncher(const cudaStream_t &stream, const float *boxes, int64_t *mask,
 void NmsNormalLauncher(const cudaStream_t &stream, const float *boxes,
                        int64_t *mask, int boxes_num, float nms_overlap_thresh);
 
-std::vector<paddle::Tensor> boxes_overlap_bev_gpu(
-    const paddle::Tensor &boxes_a, const paddle::Tensor &boxes_b) {
+std::vector<paddle::Tensor>
+boxes_overlap_bev_gpu(const paddle::Tensor &boxes_a,
+                      const paddle::Tensor &boxes_b) {
   // params boxes_a: (N, 7) [x, y, z, dx, dy, dz, heading]
   // params boxes_b: (M, 7) [x, y, z, dx, dy, dz, heading]
   // params ans_overlap: (N, M)
@@ -61,9 +62,9 @@ std::vector<paddle::Tensor> boxes_overlap_bev_gpu(
   return {ans_overlap};
 }
 
-std::vector<paddle::Tensor> boxes_iou_bev_gpu(
-    const paddle::Tensor &boxes_a_tensor,
-    const paddle::Tensor &boxes_b_tensor) {
+std::vector<paddle::Tensor>
+boxes_iou_bev_gpu(const paddle::Tensor &boxes_a_tensor,
+                  const paddle::Tensor &boxes_b_tensor) {
   // params boxes_a: (N, 7) [x, y, z, dx, dy, dz, heading]
   // params boxes_b: (M, 7) [x, y, z, dx, dy, dz, heading]
   // params ans_overlap: (N, M)
@@ -135,7 +136,8 @@ std::vector<paddle::Tensor> nms_gpu(const paddle::Tensor &boxes,
   }
 
   num_to_keep_data[0] = num_to_keep;
-  if (cudaSuccess != cudaGetLastError()) printf("Error!\n");
+  if (cudaSuccess != cudaGetLastError())
+    printf("Error!\n");
 
   return {keep, num_to_keep_tensor};
 }

paddlex/ops/iou3d_nms/iou3d_nms.h

@@ -21,10 +21,12 @@
 
 #include <vector>
 
-std::vector<paddle::Tensor> boxes_overlap_bev_gpu(
-    const paddle::Tensor &boxes_a, const paddle::Tensor &boxes_b);
-std::vector<paddle::Tensor> boxes_iou_bev_gpu(
-    const paddle::Tensor &boxes_a_tensor, const paddle::Tensor &boxes_b_tensor);
+std::vector<paddle::Tensor>
+boxes_overlap_bev_gpu(const paddle::Tensor &boxes_a,
+                      const paddle::Tensor &boxes_b);
+std::vector<paddle::Tensor>
+boxes_iou_bev_gpu(const paddle::Tensor &boxes_a_tensor,
+                  const paddle::Tensor &boxes_b_tensor);
 std::vector<paddle::Tensor> nms_gpu(const paddle::Tensor &boxes,
                                     float nms_overlap_thresh);
 std::vector<paddle::Tensor> nms_normal_gpu(const paddle::Tensor &boxes,

paddlex/ops/iou3d_nms/iou3d_nms_api.cpp

@@ -21,13 +21,15 @@
 #include "iou3d_cpu.h"
 #include "iou3d_nms.h"
 
-std::vector<paddle::DataType> BoxesIouBevCpuInferDtype(
-    paddle::DataType boxes_a_dtype, paddle::DataType boxes_b_dtype) {
+std::vector<paddle::DataType>
+BoxesIouBevCpuInferDtype(paddle::DataType boxes_a_dtype,
+                         paddle::DataType boxes_b_dtype) {
   return {boxes_a_dtype};
 }
 
-std::vector<std::vector<int64_t>> BoxesIouBevCpuInferShape(
-    std::vector<int64_t> boxes_a_shape, std::vector<int64_t> boxes_b_shape) {
+std::vector<std::vector<int64_t>>
+BoxesIouBevCpuInferShape(std::vector<int64_t> boxes_a_shape,
+                         std::vector<int64_t> boxes_b_shape) {
   return {{boxes_a_shape[0], boxes_b_shape[0]}};
 }
 
@@ -35,38 +37,42 @@ std::vector<paddle::DataType> NmsInferDtype(paddle::DataType boxes_dtype) {
   return {paddle::DataType::INT64, paddle::DataType::INT64};
 }
 
-std::vector<std::vector<int64_t>> NmsInferShape(
-    std::vector<int64_t> boxes_shape) {
+std::vector<std::vector<int64_t>>
+NmsInferShape(std::vector<int64_t> boxes_shape) {
   return {{boxes_shape[0]}, {1}};
 }
 
-std::vector<paddle::DataType> NmsNormalInferDtype(
-    paddle::DataType boxes_dtype) {
+std::vector<paddle::DataType>
+NmsNormalInferDtype(paddle::DataType boxes_dtype) {
   return {paddle::DataType::INT64, paddle::DataType::INT64};
 }
 
-std::vector<std::vector<int64_t>> NmsNormalInferShape(
-    std::vector<int64_t> boxes_shape) {
+std::vector<std::vector<int64_t>>
+NmsNormalInferShape(std::vector<int64_t> boxes_shape) {
   return {{boxes_shape[0]}, {1}};
 }
 
-std::vector<paddle::DataType> BoxesIouBevGpuInferDtype(
-    paddle::DataType boxes_a_dtype, paddle::DataType boxes_b_dtype) {
+std::vector<paddle::DataType>
+BoxesIouBevGpuInferDtype(paddle::DataType boxes_a_dtype,
+                         paddle::DataType boxes_b_dtype) {
   return {boxes_a_dtype};
 }
 
-std::vector<std::vector<int64_t>> BoxesIouBevGpuInferShape(
-    std::vector<int64_t> boxes_a_shape, std::vector<int64_t> boxes_b_shape) {
+std::vector<std::vector<int64_t>>
+BoxesIouBevGpuInferShape(std::vector<int64_t> boxes_a_shape,
+                         std::vector<int64_t> boxes_b_shape) {
   return {{boxes_a_shape[0], boxes_b_shape[0]}};
 }
 
-std::vector<paddle::DataType> BoxesOverlapBevGpuInferDtype(
-    paddle::DataType boxes_a_dtype, paddle::DataType boxes_b_dtype) {
+std::vector<paddle::DataType>
+BoxesOverlapBevGpuInferDtype(paddle::DataType boxes_a_dtype,
+                             paddle::DataType boxes_b_dtype) {
   return {boxes_a_dtype};
 }
 
-std::vector<std::vector<int64_t>> BoxesOverlapBevGpuInferShape(
-    std::vector<int64_t> boxes_a_shape, std::vector<int64_t> boxes_b_shape) {
+std::vector<std::vector<int64_t>>
+BoxesOverlapBevGpuInferShape(std::vector<int64_t> boxes_a_shape,
+                             std::vector<int64_t> boxes_b_shape) {
   return {{boxes_a_shape[0], boxes_b_shape[0]}};
 }
 

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);