Merge branch 'master' into nl21427_2

.github/workflows/daily.yaml

@@ -12,9 +12,9 @@ jobs:
     strategy:
       matrix:
         runner: [mlu370-m8]
-        mlu_ops_version : [1.3.1]
-        cntoolkit_version : [3.14.0]
-        cnnl_version: [1.26.6]
+        mlu_ops_version : [1.4.0]
+        cntoolkit_version : [3.15.2]
+        cnnl_version: [1.27.4]
     runs-on: ${{matrix.runner}}
     steps:
       - uses: actions/checkout@v3

.github/workflows/mluops_ci.yaml

@@ -39,7 +39,7 @@ jobs:
     strategy:
       matrix:
         runner: [mlu370-m8]
-        mlu_ops_version : [v1.3.1]
+        mlu_ops_version : [v1.4.0]
     runs-on: [yellow]
     steps:
       - uses: actions/checkout@v3

README.md

@@ -52,7 +52,7 @@ MLU-OPS™提供了以下功能：
   - 支持 x86_64 架构下的 Ubuntu20.04、Centos7.6、Centos8.5、Kylin10
   - MLU-OPS™ v1.0.0版本后将不再支持 Ubuntu18.04。Ubuntu22.04系统将在后续的版本提供支持。
 - 寒武纪 MLU SDK：
-  - 编译和运行时依赖 CNToolkit v3.14.0 或更高版本，CNNL v1.26.6 或者更高版本
+  - 编译和运行时依赖 CNToolkit v3.15.2 或更高版本，CNNL v1.27.4 或者更高版本
 - 寒武纪 MLU 驱动：
   - 运行时依赖驱动 v6.0.3 或更高版本
 - 外部链接库：

build.property

@@ -1,8 +1,8 @@
 {
-  "version": "1.3.1-1",
+  "version": "1.4.0-1",
   "python": "3.6.0",
-  "build_requires": {"cntoolkit": ["release","3.14.0-1"],
-                     "cnnl":["release","1.26.6-1"],
+  "build_requires": {"cntoolkit": ["release","3.15.2-1"],
+                     "cnnl":["release","1.27.4-1"],
                      "driver": "6.0.3",
                      "eigen3": "3.4.0",
                      "libxml2": "2.9.0",

docs/api_guide/update.rst

@@ -3,6 +3,27 @@ Update History
 
 This section lists contents that were made for each product release.
 
+* V1.4.0
+
+  **Date:** October 21, 2024
+
+  **Changes:**
+
+  - Added the following new operations:
+
+      - mluOpLogspace
+      - mluOpLgamma
+
+* V1.3.2
+
+  **Date:** October 21, 2024
+
+  **Changes:**
+
+  - ``exec_fft``
+
+    - optimize performance.
+
 
 * V1.3.1
 

docs/design_docs/dynamic_point_to_voxel_backward/dynamic_point_to_voxel_backward.md

@@ -11,6 +11,7 @@
 | 版本号 | 修订人 | 修订日期 | 修订描述 |
 | ----- | ----- | ------ | ------- |
 | V1.0 | xuminjie | 2023 | 首次提交 |
+| V1.1 | wangyuan | 2024.11.08 | 修复sync、算法时序引入的潜在缺陷 |
 
 - #### 内容描述
 
@@ -80,10 +81,10 @@ max模式：根据point2voxel_map，分组找出feats和voxel_feats中值相同
 | 输入限制 | 输入 `grad_voxel_feats`, `feats`, `voxel_feats`支持输入 nan 或 inf |
 | 输入参数限制 | 仅支持输入reduce_mode值为MLUOP_REDUCEMODE_MAX |
 | 数据类型限制 | 输入 `grad_voxel_feats`, `feats`, `voxel_feats` 输出 `grad_feats` 数据类型保持一致;`point2voxel_map`, `voxel_points_count`, `voxel_num`数据类型保持一致 |
-| 布局限制 | 无 |
-| 原位限制 | 不支持原位 |
+| 布局限制     | 无               |
+| 原位限制     | 不支持原位         |
 | stride 限制 | 不支持 stride 机制 |
-| 广播限制 | 不支持广播 |
+| 广播限制     | 不支持广播        |
 
 ### 1.5 验收标准
 
@@ -167,7 +168,26 @@ mluOpStatus_t MLUOP_WIN_API mluOpGetDynamicPointToVoxelBackwardWorkspaceSize(
 
 #### 3.1.1 计算原理说明
 
-`dynamic_point_to_voxel_backward` 算子包含7个输入:`reduce_type`、`grad_voxel_feats`、`feats`、`voxel_feats`、`point2voxel_map`、`voxel_point2_count`、`voxel_num`，1个输出：`grad_feats`; 根据 1.2 节算子功能, 可将算子2部分分为2个kernel来实现:
+`dynamic_point_to_voxel_backward` 算子包含7个输入，1个输出。
+
+input:
+1. `grad_feats`，`shape=[N,C]`
+2. `grad_voxel_feats`，`shape=[M,C]`
+3. `voxel_feats`，`shape=[M,C]`
+4. `point2voxel_map`，`shape=[N]`
+5. `voxel_point2_count`，`shape=[M]`
+6. `voxel_num`，`hape=[1]`
+7. `reduce_type`
+
+output：
+1. `grad_feats`，`shape=[N,C]` 
+
+`dynamic_point_to_voxel_forward` 中:
+- `coor` 表示 N 个点云数据对应在三维（三维体素网格坐标）具体坐标信息，`feats` 表示有 N 个点云数据，每个点云有 C 个特征
+- `feats`、`coors` 中数据是一一对应的
+- 该算子将全正坐标外坐标刷-1、去重、排序后，通过 `reduce_mode` ，对 `feats` 中数据进行处理
+
+根据 1.2 节算子功能，可将`dynamic_point_to_voxel_forward` 分为2个kernel来实现:
 
 - #### 计算逻辑层面
 
@@ -176,7 +196,22 @@ mluOpStatus_t MLUOP_WIN_API mluOpGetDynamicPointToVoxelBackwardWorkspaceSize(
 
 先将`voxel_from`初始化成最大值N;
 
-根据`point2voxel_map`中记录的“特征与体素特征的映射关系”。对比输入的特征`feats`和体素特征 `voxel_feats`，对于第i个体素特征`voxel_feats[i]`，如果第j个特征与之相等，则认为这个体素特征是由该特征得到的。在中间结果`voxel_from`中保存两者的下标关系，使`voxel_from[i]=j`，该中间结果使用workspace保存。
+根据`point2voxel_map`中记录的“特征与体素特征的映射关系”。对比输入的特征`feats`和体素特征 `voxel_feats`：
+1. 对于第 `i` 个体素特征中 `c(c=0,1,2,...,C-1)` 维特征 `voxel_feats[i,c]`，若与第 `j` 个特征的 `c` 维特征的 `feats[j, c]`相等，则认为这个体素特征是由该特征得到的
+2. 若 `voxel_feats[i,c]` 与多个特征 `feats[j, c]`、`feats[k, c]` 相等，此时认为下标靠前的特征`feats[j, c]`（`j<k`）是 `voxel_feats[i,c]` 对应点
+3. 新建 `voxel_from` 保存上述两者的下标关系
+4. 举个简单例子
+```c++
+// feats 中数据在 voxel_feats 中的映射如下
+point2voxel_map = [0, 0, 1, 1, 2, 3, ...]
+
+// 依据映射关系 load feats,voxel_feats
+deal_feats       = [feats[0], feats[1], feats[2], feats[3],...,]
+dead_voxel_feats = [voxel_feats[0], voxel_feats[0], voxel_feats[1], voxel_feats[1], voxel_feats[2],...]
+
+// 计算映射下标 voxel_from，对于多个 feats[j] 相同，取其中最小值
+voxel_from = [0, 2, 4, 5, ...]
+```
 
 - kernel2
 

docs/design_docs/dynamic_point_to_voxel_forward/dynamic_point_to_voxel_forward.md

@@ -76,9 +76,9 @@ grid\_z = round((coors\_z\_max - coors\_z\_min) / voxel\_z)
 
 利用点云的位置信息可进一步获取其在三维空间中对应的体素坐标。其计算公式如下:
 
-1）feats: [N, C], 表示有 N 个点云数据，每个点云有 C 个特征；
+1）`feats`: [N, C], 表示有 N 个点云数据，每个点云有 C 个特征；
 
-2）point_coors: [N, 3], 表示 N 个点云数据对应在三维空间中具体坐标信息；
+2）`point_coors`: [N, 3], 表示 N 个点云数据对应在三维空间中具体坐标信息，`feats`与`coors` 中数据是一一对应的
 
 将点云所在三维空间坐标信息转为三维体素网格坐标，则该点所在体素坐标 (c_x, c_y, c_z) 的计算公式为：
 
@@ -100,40 +100,57 @@ c\_z = floorf((point_coors[idx][2] - coors\_z\_min) / voxel\_z)
 1）对 `coors` 体素坐标进行有效值检查，如果 `coors` 中 x、y、z 的值有一个小于 0 则都赋值为 -1;
 
 ```c++
-coors: [[-3,5,2],[-2,1,4],[6,7,8],[2,4,6]]
+coors: [[-3,5,2],[-2,1,4],[6,7,8],[6,7,8],[2,4,6]]
 result:
-coors: [[-1,-1,-1],[-1,-1,-1],[6,7,8],[2,4,6]]
+coors: [[-1,-1,-1],[-1,-1,-1],[6,7,8],[6,7,8],[2,4,6]]
 ```
 
 2）将体素坐标 `coors` 进行排序、去重，得到新的体素坐标 `voxel_coors`; 保存去重后体素的个数 num_voxels 到 `voxel_num`; 保存 `coors` 中每个体素坐标在 `voxel_coors` 中对应的索引到 `point2voxel_map`; 保存 `voxel_coors` 中每个体素坐标在 `coors` 中出现的个数到 `voxel_points_count`;
 
  ![point2voxel](./point2voxel.png) 
 
+该步骤其实是 `unique` 操作：
+- `mode = sort`
+- `input` 为 `coors`
+- `output` 为 `voxel_coors`
+- `indices` 为 `point2voxel_map`
+- `count` 为 `voxel_num`
+
  ```c++
- coors: [[-1,-1,-1],[-1,-1,-1],[6,7,8],[2,4,6]]
+ coors: [[-1,-1,-1],[-1,-1,-1],[6,7,8],[6,7,8],[2,4,6]]
+
  result:
- voxel_coors: [[-1,-1,-1],[6,7,8],[2,4,6]]
- point2voxel_map:[0,0,1,2]
- voxel_points_count: [2,1,1]
+ voxel_coors: [[-1,-1,-1],[2,4,6],[6,7,8]]  // 坐标 coors 进行排序、去重
+ point2voxel_map:[0,0,2,1,1]                // 记录 coors 中元素在 voxel_coors 中的 idx
+ voxel_points_count: [2,1,2]                // 记录 voxel_coors 每个元素的 count
  voxel_num:[3]
  ```
 
-3）如果 `voxel_coors[0][0]` 小于 0，则对 2）中输出进行修整;
+3）如果 `voxel_coors[i,:], i=0,1,2,...` 中包含小于 `0` 元素，则删除 `voxel_coors[i,:]` 以及 `voxel_points_count` 中对应 `count`，同时 `point2voxel_map -= 1`
 
 ```c++
-voxel_coors: [[-1,-1,-1],[6,7,8],[2,4,6]]
-point2voxel_map:[0,0,1,2]
-voxel_points_count: [2,1,1]
-voxel_num:[3]
 result:
-voxel_coors: [[6,7,8],[2,4,6]]
-point2voxel_map:[-1,-1,0,1]
-voxel_points_count: [1,1]
+voxel_coors: [[2,4,6],[6,7,8]]
+point2voxel_map:[-1,-1,1,1,0]
+voxel_points_count: [1,2]
 voxel_num:[2]
 ```
 
 4）遍历 `feats` 中每个点，在特征维度上，对每个值根据 `reduce_type` 的方法进行计算，将结果保存到 `voxel_feats` 中; 当 `reduce_type` = `max`, 在特征维度上对每个值取最大的值; 当 `reduce_type` = `mean`, 将特征维度每个值都累加到 `voxel_feats` 对应位置中，再利用 `voxel_points_count` 获取该体素位置在原始体素中出现的个数，再对 `voxel_feats` 的特征维度求平均。
 
+```c++
+coors: [[-1,-1,-1],[-1,-1,-1],[6,7,8],[6,7,8],[2,4,6]]
+voxel_coors: [[2,4,6],[6,7,8]]
+point2voxel_map:[-1,-1,1,1,0]
+
+// point2voxel_map 中 0,1 为-1，表示该位置 feats 数据无效
+// 以 reduce_type=max 为例:
+//    voxel_feats[0] 为 point2voxel_map 中 0 值对应的 feats 进行reduce
+//    voxel_feats[1] 为 point2voxel_map 中 1 值对应的 feats 进行reduce
+voxel_feats[0, i] = max(feats[2,i], feats[3,i]) 
+voxel_feats[1]    = feats[4]                          
+```
+
 - #### nan/inf
 
 1）feats 支持 nan/inf;

docs/design_docs/roi_align_rotated/roi_align_rotated.md

@@ -37,7 +37,7 @@ roi_align_rotated算子应用于FOTS网络结构中，以双线性插值的方
 |是否需要支持原位        | 否   |
 | 是否需要支持stride机制  | 否       |
 | 是否需要支持广播  | 否                       |
-| 0元素检查是否直接返回  | 是                                            |                                                      |
+| 0元素检查是否直接返回  | 是                                            |
 
 ### 1.2 算子功能和应用场景描述
 
@@ -208,7 +208,7 @@ mluOpStatus_t MLUOP_WIN_API mluOpRoiAlignRotatedBackward(mluOpHandle_t handle,
 |---------|---------|---------|---------|
 |  input  |  output |  input  |  output |
 |---------|---------|---------|---------|
-    
+
 ```
 与前向类似，反向计算时把空间均分为4部分，保持每次处理的input和output的大小相同。
 ### 3.4 性能优化设计
@@ -252,7 +252,7 @@ RoiAlign类的算子是IO瓶颈，在一个bin中需要处理多个采样点，
  6、output的HW维度需要分别与参数中的pooled_height和pooled_width保持一致。
 
  反向：
- 
+
  1、指针为空防呆；
 
  2、0元素检查防呆，VLOG(5)打印信息；