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

paddlex/ops/iou3d_nms/iou3d_cpu.cpp

@@ -0,0 +1,264 @@
+// 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.
+
+/*
+3D Rotated IoU Calculation (CPU)
+Written by Shaoshuai Shi
+All Rights Reserved 2020.
+*/
+
+#include "iou3d_cpu.h"
+
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+#include <math.h>
+#include <paddle/extension.h>
+#include <stdio.h>
+
+#include <vector>
+
+inline float min(float a, float b) { return a > b ? b : a; }
+
+inline float max(float a, float b) { return a > b ? a : b; }
+
+const float EPS = 1e-8;
+struct Point {
+  float x, y;
+  __device__ Point() {}
+  __device__ Point(double _x, double _y) { x = _x, y = _y; }
+
+  __device__ void set(float _x, float _y) {
+    x = _x;
+    y = _y;
+  }
+
+  __device__ Point operator+(const Point &b) const {
+    return Point(x + b.x, y + b.y);
+  }
+
+  __device__ Point operator-(const Point &b) const {
+    return Point(x - b.x, y - b.y);
+  }
+};
+
+inline float cross(const Point &a, const Point &b) {
+  return a.x * b.y - a.y * b.x;
+}
+
+inline float cross(const Point &p1, const Point &p2, const Point &p0) {
+  return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
+}
+
+inline int check_rect_cross(const Point &p1, const Point &p2, const Point &q1,
+                            const Point &q2) {
+  int ret = min(p1.x, p2.x) <= max(q1.x, q2.x) &&
+            min(q1.x, q2.x) <= max(p1.x, p2.x) &&
+            min(p1.y, p2.y) <= max(q1.y, q2.y) &&
+            min(q1.y, q2.y) <= max(p1.y, p2.y);
+  return ret;
+}
+
+inline int check_in_box2d(const float *box, const Point &p) {
+  // params: (7) [x, y, z, dx, dy, dz, heading]
+  const float MARGIN = 1e-2;
+
+  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
+  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;
+
+  return (fabs(rot_x) < box[3] / 2 + MARGIN &&
+          fabs(rot_y) < box[4] / 2 + MARGIN);
+}
+
+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;
+
+  // check cross standing
+  float s1 = cross(q0, p1, p0);
+  float s2 = cross(p1, q1, p0);
+  float s3 = cross(p0, q1, q0);
+  float s4 = cross(q1, p1, q0);
+
+  if (!(s1 * s2 > 0 && s3 * s4 > 0)) return 0;
+
+  // calculate intersection of two lines
+  float s5 = cross(q1, p1, p0);
+  if (fabs(s5 - s1) > EPS) {
+    ans.x = (s5 * q0.x - s1 * q1.x) / (s5 - s1);
+    ans.y = (s5 * q0.y - s1 * q1.y) / (s5 - s1);
+
+  } else {
+    float a0 = p0.y - p1.y, b0 = p1.x - p0.x, c0 = p0.x * p1.y - p1.x * p0.y;
+    float a1 = q0.y - q1.y, b1 = q1.x - q0.x, c1 = q0.x * q1.y - q1.x * q0.y;
+    float D = a0 * b1 - a1 * b0;
+
+    ans.x = (b0 * c1 - b1 * c0) / D;
+    ans.y = (a1 * c0 - a0 * c1) / D;
+  }
+
+  return 1;
+}
+
+inline void rotate_around_center(const Point &center, const float angle_cos,
+                                 const float angle_sin, Point &p) {
+  float new_x =
+      (p.x - center.x) * angle_cos + (p.y - center.y) * (-angle_sin) + center.x;
+  float new_y =
+      (p.x - center.x) * angle_sin + (p.y - center.y) * angle_cos + center.y;
+  p.set(new_x, new_y);
+}
+
+inline int point_cmp(const Point &a, const Point &b, const Point &center) {
+  return atan2(a.y - center.y, a.x - center.x) >
+         atan2(b.y - center.y, b.x - center.x);
+}
+
+inline float box_overlap(const float *box_a, const float *box_b) {
+  // params: box_a (7) [x, y, z, dx, dy, dz, heading]
+  // params: box_b (7) [x, y, z, dx, dy, dz, heading]
+
+  //    float a_x1 = box_a[0], a_y1 = box_a[1], a_x2 = box_a[2], a_y2 =
+  //    box_a[3], a_angle = box_a[4];
+  //    float b_x1 = box_b[0], b_y1 = box_b[1], b_x2 = box_b[2], b_y2 =
+  //    box_b[3], b_angle = box_b[4];
+  float a_angle = box_a[6], b_angle = box_b[6];
+  float a_dx_half = box_a[3] / 2, b_dx_half = box_b[3] / 2,
+        a_dy_half = box_a[4] / 2, b_dy_half = box_b[4] / 2;
+  float a_x1 = box_a[0] - a_dx_half, a_y1 = box_a[1] - a_dy_half;
+  float a_x2 = box_a[0] + a_dx_half, a_y2 = box_a[1] + a_dy_half;
+  float b_x1 = box_b[0] - b_dx_half, b_y1 = box_b[1] - b_dy_half;
+  float b_x2 = box_b[0] + b_dx_half, b_y2 = box_b[1] + b_dy_half;
+
+  Point center_a(box_a[0], box_a[1]);
+  Point center_b(box_b[0], box_b[1]);
+
+  Point box_a_corners[5];
+  box_a_corners[0].set(a_x1, a_y1);
+  box_a_corners[1].set(a_x2, a_y1);
+  box_a_corners[2].set(a_x2, a_y2);
+  box_a_corners[3].set(a_x1, a_y2);
+
+  Point box_b_corners[5];
+  box_b_corners[0].set(b_x1, b_y1);
+  box_b_corners[1].set(b_x2, b_y1);
+  box_b_corners[2].set(b_x2, b_y2);
+  box_b_corners[3].set(b_x1, b_y2);
+
+  // get oriented corners
+  float a_angle_cos = cos(a_angle), a_angle_sin = sin(a_angle);
+  float b_angle_cos = cos(b_angle), b_angle_sin = sin(b_angle);
+
+  for (int k = 0; k < 4; k++) {
+    rotate_around_center(center_a, a_angle_cos, a_angle_sin, box_a_corners[k]);
+    rotate_around_center(center_b, b_angle_cos, b_angle_sin, box_b_corners[k]);
+  }
+
+  box_a_corners[4] = box_a_corners[0];
+  box_b_corners[4] = box_b_corners[0];
+
+  // get intersection of lines
+  Point cross_points[16];
+  Point poly_center;
+  int cnt = 0, flag = 0;
+
+  poly_center.set(0, 0);
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      flag = intersection(box_a_corners[i + 1], box_a_corners[i],
+                          box_b_corners[j + 1], box_b_corners[j],
+                          cross_points[cnt]);
+      if (flag) {
+        poly_center = poly_center + cross_points[cnt];
+        cnt++;
+      }
+    }
+  }
+
+  // check corners
+  for (int k = 0; k < 4; k++) {
+    if (check_in_box2d(box_a, box_b_corners[k])) {
+      poly_center = poly_center + box_b_corners[k];
+      cross_points[cnt] = box_b_corners[k];
+      cnt++;
+    }
+    if (check_in_box2d(box_b, box_a_corners[k])) {
+      poly_center = poly_center + box_a_corners[k];
+      cross_points[cnt] = box_a_corners[k];
+      cnt++;
+    }
+  }
+
+  poly_center.x /= cnt;
+  poly_center.y /= cnt;
+
+  // sort the points of polygon
+  Point temp;
+  for (int j = 0; j < cnt - 1; j++) {
+    for (int i = 0; i < cnt - j - 1; i++) {
+      if (point_cmp(cross_points[i], cross_points[i + 1], poly_center)) {
+        temp = cross_points[i];
+        cross_points[i] = cross_points[i + 1];
+        cross_points[i + 1] = temp;
+      }
+    }
+  }
+
+  // get the overlap areas
+  float area = 0;
+  for (int k = 0; k < cnt - 1; k++) {
+    area += cross(cross_points[k] - cross_points[0],
+                  cross_points[k + 1] - cross_points[0]);
+  }
+
+  return fabs(area) / 2.0;
+}
+
+inline float iou_bev(const float *box_a, const float *box_b) {
+  // params: box_a (7) [x, y, z, dx, dy, dz, heading]
+  // params: box_b (7) [x, y, z, dx, dy, dz, heading]
+  float sa = box_a[3] * box_a[4];
+  float sb = box_b[3] * box_b[4];
+  float s_overlap = box_overlap(box_a, 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) {
+  // 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)
+
+  int num_boxes_a = boxes_a_tensor.shape()[0];
+  int num_boxes_b = boxes_b_tensor.shape()[0];
+  const float *boxes_a = boxes_a_tensor.data<float>();
+  const float *boxes_b = boxes_b_tensor.data<float>();
+  auto ans_iou_tensor =
+      paddle::empty({num_boxes_a, num_boxes_b}, paddle::DataType::FLOAT32,
+                    paddle::CPUPlace());
+
+  float *ans_iou = ans_iou_tensor.data<float>();
+
+  for (int i = 0; i < num_boxes_a; i++) {
+    for (int j = 0; j < num_boxes_b; j++) {
+      ans_iou[i * num_boxes_b + j] = iou_bev(boxes_a + i * 7, boxes_b + j * 7);
+    }
+  }
+  return {ans_iou_tensor};
+}

paddlex/ops/iou3d_nms/iou3d_cpu.h

@@ -0,0 +1,27 @@
+// 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.
+
+#ifndef IOU3D_CPU_H
+#define IOU3D_CPU_H
+
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+#include <paddle/extension.h>
+
+#include <vector>
+
+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

@@ -0,0 +1,204 @@
+// 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.
+
+/*
+3D IoU Calculation and Rotated NMS(modified from 2D NMS written by others)
+Written by Shaoshuai Shi
+All Rights Reserved 2019-2020.
+*/
+
+#include "iou3d_nms.h"
+
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+#include <paddle/extension.h>
+
+#include <vector>
+
+#define DIVUP(m, n) ((m) / (n) + ((m) % (n) > 0))
+
+const int THREADS_PER_BLOCK_NMS = sizeof(int64_t) * 8;
+
+void BoxesOverlapLauncher(const cudaStream_t &stream, const int num_a,
+                          const float *boxes_a, const int num_b,
+                          const float *boxes_b, float *ans_overlap);
+void BoxesIouBevLauncher(const cudaStream_t &stream, const int num_a,
+                         const float *boxes_a, const int num_b,
+                         const float *boxes_b, float *ans_iou);
+void NmsLauncher(const cudaStream_t &stream, const float *boxes, int64_t *mask,
+                 int boxes_num, float nms_overlap_thresh);
+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) {
+  // 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)
+  int num_a = boxes_a.shape()[0];
+  int num_b = boxes_b.shape()[0];
+
+  const float *boxes_a_data = boxes_a.data<float>();
+  const float *boxes_b_data = boxes_b.data<float>();
+  auto ans_overlap = paddle::empty({num_a, num_b}, paddle::DataType::FLOAT32,
+                                   paddle::GPUPlace());
+  float *ans_overlap_data = ans_overlap.data<float>();
+
+  BoxesOverlapLauncher(boxes_a.stream(), num_a, boxes_a_data, num_b,
+                       boxes_b_data, ans_overlap_data);
+
+  return {ans_overlap};
+}
+
+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)
+
+  int num_a = boxes_a_tensor.shape()[0];
+  int num_b = boxes_b_tensor.shape()[0];
+
+  const float *boxes_a_data = boxes_a_tensor.data<float>();
+  const float *boxes_b_data = boxes_b_tensor.data<float>();
+  auto ans_iou_tensor = paddle::empty({num_a, num_b}, paddle::DataType::FLOAT32,
+                                      paddle::GPUPlace());
+  float *ans_iou_data = ans_iou_tensor.data<float>();
+
+  BoxesIouBevLauncher(boxes_a_tensor.stream(), num_a, boxes_a_data, num_b,
+                      boxes_b_data, ans_iou_data);
+
+  return {ans_iou_tensor};
+}
+
+std::vector<paddle::Tensor> nms_gpu(const paddle::Tensor &boxes,
+                                    float nms_overlap_thresh) {
+  // params boxes: (N, 7) [x, y, z, dx, dy, dz, heading]
+  auto keep = paddle::empty({boxes.shape()[0]}, paddle::DataType::INT32,
+                            paddle::CPUPlace());
+  auto num_to_keep_tensor =
+      paddle::empty({1}, paddle::DataType::INT32, paddle::CPUPlace());
+  int *num_to_keep_data = num_to_keep_tensor.data<int>();
+
+  int boxes_num = boxes.shape()[0];
+  const float *boxes_data = boxes.data<float>();
+  int *keep_data = keep.data<int>();
+
+  const int col_blocks = DIVUP(boxes_num, THREADS_PER_BLOCK_NMS);
+
+  // int64_t *mask_data = NULL;
+  // CHECK_ERROR(cudaMalloc((void**)&mask_data, boxes_num * col_blocks *
+  // sizeof(int64_t)));
+  auto mask = paddle::empty({boxes_num * col_blocks}, paddle::DataType::INT64,
+                            paddle::GPUPlace());
+  int64_t *mask_data = mask.data<int64_t>();
+  NmsLauncher(boxes.stream(), boxes_data, mask_data, boxes_num,
+              nms_overlap_thresh);
+
+  // std::vector<int64_t> mask_cpu(boxes_num * col_blocks);
+
+  // CHECK_ERROR(cudaMemcpy(&mask_cpu[0], mask_data, boxes_num * col_blocks *
+  // sizeof(int64_t),
+  //                       cudaMemcpyDeviceToHost));
+  const paddle::Tensor mask_cpu_tensor = mask.copy_to(paddle::CPUPlace(), true);
+  const int64_t *mask_cpu = mask_cpu_tensor.data<int64_t>();
+  // cudaFree(mask_data);
+
+  int64_t remv_cpu[col_blocks];
+  memset(remv_cpu, 0, col_blocks * sizeof(int64_t));
+
+  int num_to_keep = 0;
+
+  for (int i = 0; i < boxes_num; i++) {
+    int nblock = i / THREADS_PER_BLOCK_NMS;
+    int inblock = i % THREADS_PER_BLOCK_NMS;
+
+    if (!(remv_cpu[nblock] & (1ULL << inblock))) {
+      keep_data[num_to_keep++] = i;
+      const int64_t *p = &mask_cpu[0] + i * col_blocks;
+      for (int j = nblock; j < col_blocks; j++) {
+        remv_cpu[j] |= p[j];
+      }
+    }
+  }
+
+  num_to_keep_data[0] = num_to_keep;
+  if (cudaSuccess != cudaGetLastError()) printf("Error!\n");
+
+  return {keep, num_to_keep_tensor};
+}
+
+std::vector<paddle::Tensor> nms_normal_gpu(const paddle::Tensor &boxes,
+                                           float nms_overlap_thresh) {
+  // params boxes: (N, 7) [x, y, z, dx, dy, dz, heading]
+  // params keep: (N)
+
+  auto keep = paddle::empty({boxes.shape()[0]}, paddle::DataType::INT32,
+                            paddle::CPUPlace());
+  auto num_to_keep_tensor =
+      paddle::empty({1}, paddle::DataType::INT32, paddle::CPUPlace());
+  int *num_to_keep_data = num_to_keep_tensor.data<int>();
+  int boxes_num = boxes.shape()[0];
+  const float *boxes_data = boxes.data<float>();
+  int *keep_data = keep.data<int>();
+
+  const int col_blocks = DIVUP(boxes_num, THREADS_PER_BLOCK_NMS);
+
+  // int64_t *mask_data = NULL;
+  // CHECK_ERROR(cudaMalloc((void**)&mask_data, boxes_num * col_blocks *
+  // sizeof(int64_t)));
+  auto mask = paddle::empty({boxes_num * col_blocks}, paddle::DataType::INT64,
+                            paddle::GPUPlace());
+  int64_t *mask_data = mask.data<int64_t>();
+  NmsNormalLauncher(boxes.stream(), boxes_data, mask_data, boxes_num,
+                    nms_overlap_thresh);
+
+  // int64_t mask_cpu[boxes_num * col_blocks];
+  // int64_t *mask_cpu = new int64_t [boxes_num * col_blocks];
+  // std::vector<int64_t> mask_cpu(boxes_num * col_blocks);
+
+  // CHECK_ERROR(cudaMemcpy(&mask_cpu[0], mask_data, boxes_num * col_blocks *
+  // sizeof(int64_t),
+  //                       cudaMemcpyDeviceToHost));
+
+  // cudaFree(mask_data);
+
+  const paddle::Tensor mask_cpu_tensor = mask.copy_to(paddle::CPUPlace(), true);
+  const int64_t *mask_cpu = mask_cpu_tensor.data<int64_t>();
+
+  int64_t remv_cpu[col_blocks];
+  memset(remv_cpu, 0, col_blocks * sizeof(int64_t));
+
+  int num_to_keep = 0;
+
+  for (int i = 0; i < boxes_num; i++) {
+    int nblock = i / THREADS_PER_BLOCK_NMS;
+    int inblock = i % THREADS_PER_BLOCK_NMS;
+
+    if (!(remv_cpu[nblock] & (1ULL << inblock))) {
+      keep_data[num_to_keep++] = i;
+      const int64_t *p = &mask_cpu[0] + i * col_blocks;
+      for (int j = nblock; j < col_blocks; j++) {
+        remv_cpu[j] |= p[j];
+      }
+    }
+  }
+
+  num_to_keep_data[0] = num_to_keep;
+  if (cudaSuccess != cudaGetLastError()) {
+    printf("Error!\n");
+  }
+  return {keep, num_to_keep_tensor};
+}

paddlex/ops/iou3d_nms/iou3d_nms.h

@@ -0,0 +1,33 @@
+// 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.
+
+#ifndef IOU3D_NMS_H
+#define IOU3D_NMS_H
+
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+#include <paddle/extension.h>
+
+#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> nms_gpu(const paddle::Tensor &boxes,
+                                    float nms_overlap_thresh);
+std::vector<paddle::Tensor> nms_normal_gpu(const paddle::Tensor &boxes,
+                                           float nms_overlap_thresh);
+
+#endif

paddlex/ops/iou3d_nms/iou3d_nms_api.cpp

@@ -0,0 +1,108 @@
+// 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.
+
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+#include <paddle/extension.h>
+
+#include <vector>
+
+#include "iou3d_cpu.h"
+#include "iou3d_nms.h"
+
+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) {
+  return {{boxes_a_shape[0], boxes_b_shape[0]}};
+}
+
+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) {
+  return {{boxes_shape[0]}, {1}};
+}
+
+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) {
+  return {{boxes_shape[0]}, {1}};
+}
+
+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) {
+  return {{boxes_a_shape[0], boxes_b_shape[0]}};
+}
+
+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) {
+  return {{boxes_a_shape[0], boxes_b_shape[0]}};
+}
+
+PD_BUILD_OP(boxes_iou_bev_cpu)
+    .Inputs({"boxes_a_tensor", " boxes_b_tensor"})
+    .Outputs({"ans_iou_tensor"})
+    .SetKernelFn(PD_KERNEL(boxes_iou_bev_cpu))
+    .SetInferDtypeFn(PD_INFER_DTYPE(BoxesIouBevCpuInferDtype))
+    .SetInferShapeFn(PD_INFER_SHAPE(BoxesIouBevCpuInferShape));
+
+PD_BUILD_OP(boxes_iou_bev_gpu)
+    .Inputs({"boxes_a_tensor", " boxes_b_tensor"})
+    .Outputs({"ans_iou_tensor"})
+    .SetKernelFn(PD_KERNEL(boxes_iou_bev_gpu))
+    .SetInferDtypeFn(PD_INFER_DTYPE(BoxesIouBevGpuInferDtype))
+    .SetInferShapeFn(PD_INFER_SHAPE(BoxesIouBevGpuInferShape));
+
+PD_BUILD_OP(boxes_overlap_bev_gpu)
+    .Inputs({"boxes_a", " boxes_b"})
+    .Outputs({"ans_overlap"})
+    .SetKernelFn(PD_KERNEL(boxes_overlap_bev_gpu))
+    .SetInferDtypeFn(PD_INFER_DTYPE(BoxesOverlapBevGpuInferDtype))
+    .SetInferShapeFn(PD_INFER_SHAPE(BoxesOverlapBevGpuInferShape));
+
+PD_BUILD_OP(nms_gpu)
+    .Inputs({"boxes"})
+    .Outputs({"keep", "num_to_keep"})
+    .Attrs({"nms_overlap_thresh: float"})
+    .SetKernelFn(PD_KERNEL(nms_gpu))
+    .SetInferDtypeFn(PD_INFER_DTYPE(NmsInferDtype))
+    .SetInferShapeFn(PD_INFER_SHAPE(NmsInferShape));
+
+PD_BUILD_OP(nms_normal_gpu)
+    .Inputs({"boxes"})
+    .Outputs({"keep", "num_to_keep"})
+    .Attrs({"nms_overlap_thresh: float"})
+    .SetInferShapeFn(PD_INFER_SHAPE(NmsNormalInferShape))
+    .SetKernelFn(PD_KERNEL(nms_normal_gpu))
+    .SetInferDtypeFn(PD_INFER_DTYPE(NmsNormalInferDtype));