CANN ops-nn ForeachPowScalarList 算子实战:aclnn 两段式接口实现张量列表逐元素幂运算
CANN ops-nn ForeachPowScalarList 算子实战:aclnn 两段式接口实现张量列表逐元素幂运算
本篇技术指南围绕 CANN ops-nn 仓库中的 ForeachPowScalarList 算子及其对外接口 aclnnForeachPowScalarList 展开,完整讲解该算子的产品支持范围、数学定义、两段式调用流程、全部参数约束与返回码语义,并给出可编译运行的 C++ 调用示例。同时结合仓库源码(OpDef 定义、AscendC kernel 实现、tiling 策略与测试用例)深入剖析其底层实现原理,帮助读者在 Atlas 系列 NPU 上正确、高效地使用该接口完成"张量列表 × 标量列表"的批量幂运算。
算子概述与产品支持情况
ForeachPowScalarList 是 CANN ops-nn 仓库 foreach/foreach_pow_scalar_list 目录下的一个 foreach 系列算子,对应 PyTorch 的 torch._foreach_pow 语义。它接收一个张量列表 x 和一个等长的标量列表 exponent,对列表中每个张量分别执行一次以对应标量为指数的幂运算,最终输出一个新的张量列表 y。
该算子对外暴露为 aclnn 接口,其产品支持情况如下(详见 docs/aclnnForeachPowScalarList.md 与 README.md):
| 产品 | 是否支持 |
|---|---|
| Ascend 950PR / Ascend 950DT | 支持 |
| Atlas A3 训练系列产品 / Atlas A3 推理系列产品 | 支持 |
| Atlas A2 训练系列产品 / Atlas A2 推理系列产品 | 支持 |
| Atlas 200I/500 A2 推理产品 | 不支持 |
| Atlas 推理系列产品 | 不支持 |
| Atlas 训练系列产品 | 不支持 |
| Kirin X90 处理器系列产品 | 支持 |
| Kirin 9030 处理器系列产品 | 支持 |
需要注意的是,README 中还额外注明:Kirin X90 / Kirin 9030 处理器系列产品上,x 和 y 的数据类型不支持 BFLOAT16。这一点在源码中也有印证——foreach_pow_scalar_list_def.cpp 中 Kirin 平台的 tensor_dtype_list_kirin 仅包含 {DT_FLOAT16, DT_FLOAT, DT_INT32},排除了 DT_BF16。
功能说明与计算公式
接口功能:对输入张量列表 x 中的每个张量进行指数运算,指数为标量列表 exponent 中与之对应的标量,即逐张量、逐元素地计算幂。
计算公式定义如下:
其中 n 为张量列表中张量的个数,要求标量列表 exponent 的元素个数与张量列表 x 中 Tensor 的个数相等,二者按下标一一对应。
两段式接口与函数原型
每个 aclnn 算子都采用两段式接口设计。必须先调用 aclnnForeachPowScalarListGetWorkspaceSize 接口,获取计算所需的 workspace 大小以及包含算子计算流程的执行器;再调用 aclnnForeachPowScalarList 接口执行实际计算。
第一段接口(获取 workspace 大小与执行器):
aclnnStatus aclnnForeachPowScalarListGetWorkspaceSize(
const aclTensorList *x,
const aclScalarList *scalars,
const aclTensorList *out,
uint64_t *workspaceSize,
aclOpExecutor **executor)
第二段接口(执行计算):
aclnnStatus aclnnForeachPowScalarList(
void *workspace,
uint64_t workspaceSize,
aclOpExecutor *executor,
aclrtStream stream)
aclnnForeachPowScalarListGetWorkspaceSize 参数详解
第一段接口完成入参校验、workspace 大小计算与执行器创建,其参数说明如下:
| 参数名 | 输入/输出 | 描述 | 使用说明 | 数据类型 | 数据格式 | 维度(shape) | 非连续Tensor |
|---|---|---|---|---|---|---|---|
| x(aclTensorList*) | 输入 | 表示进行 n 次方运算的底数,对应公式中的 x |
支持空 Tensor;该参数中所有 Tensor 的数据类型保持一致 | FLOAT32、FLOAT16、INT32、BFLOAT16 | ND | 0-8 | √ |
| scalars(aclScalarList*) | 输入 | 表示进行 n 次方运算的指数,对应公式中的 exponent |
元素个数与 x 中 Tensor 的个数相等;数据类型与入参 x 具有一定对应关系(见下文);取值的绝对值必须小于等于 (2^31-1) |
FLOAT32、INT64 | - | - | - |
| out(aclTensorList*) | 输出 | 表示进行 n 次方运算的输出结果,对应公式中的 y |
支持空 Tensor;该参数中所有 Tensor 的数据类型保持一致;数据类型和数据格式与入参 x 一致,shape size 大于等于入参 x 的 shape size |
FLOAT32、FLOAT16、INT32、BFLOAT16 | ND | 0-8 | × |
| workspaceSize(uint64_t*) | 输出 | 返回需要在 Device 侧申请的 workspace 大小 | - | - | - | - | - |
| executor(aclOpExecutor**) | 输出 | 返回 op 执行器,包含了算子计算流程 | - | - | - | - | - |
其中 scalars 与 x 的数据类型对应关系如下:
- 当
x的数据类型为 FLOAT32、FLOAT16、BFLOAT16 时,scalars数据类型支持 FLOAT32; - 当
x的数据类型为 INT32 时,scalars数据类型支持 INT64。
该对应关系在算子注册源码中同样可以验证。foreach_pow_scalar_list_def.cpp 中通过 DtypeTensor2Scalar 工具将输入张量类型逐一映射为对应的标量类型;foreach_pow_scalar_list_proto.h 的图模式 IR 也声明 x/y 支持 {DT_FLOAT, DT_FLOAT16, DT_INT32, DT_BF16},而 scalars 支持 {DT_FLOAT, DT_INT64}。
另外需要注意:
- 底数
x支持非连续 Tensor(表格中"非连续Tensor"列为 √),但输出out不支持非连续 Tensor(列为 ×),这是 README 约束说明中明确指出的限制; x与out支持 0-8 维的 ND 格式张量,超过 8 维会触发错误返回。
aclnnForeachPowScalarList 参数详解
第二段接口直接使用第一段接口产出的 workspace 与 executor 发起计算,参数说明如下:
| 参数名 | 输入/输出 | 描述 |
|---|---|---|
| workspace | 输入 | 在 Device 侧申请的 workspace 内存地址 |
| workspaceSize | 输入 | 在 Device 侧申请的 workspace 大小,由第一段接口 aclnnForeachPowScalarListGetWorkspaceSize 获取 |
| executor | 输入 | op 执行器,包含了算子计算流程 |
| stream | 输入 | 指定执行任务的 Stream |
返回值与错误码
两个接口均返回 aclnnStatus 状态码,具体参见 aclnn 返回码。第一段接口完成入参校验,出现以下场景时报错:
| 返回码 | 错误码 | 描述 |
|---|---|---|
| ACLNN_ERR_PARAM_NULLPTR | 161001 | 传入的 x、scalars、out 是空指针 |
| ACLNN_ERR_PARAM_INVALID | 161002 | x、scalars、out 的数据类型不在支持的范围之内 |
| ACLNN_ERR_PARAM_INVALID | 161002 | x 和 out 的数据类型不一致 |
| ACLNN_ERR_INNER_TILING_ERROR | 561002 | x 与 out 的 shape 不满足约束 |
| ACLNN_ERR_INNER_TILING_ERROR | 561002 | x 或 out 中的 Tensor 的数据类型不一致 |
| ACLNN_ERR_INNER_TILING_ERROR | 561002 | x 或 out 中的 Tensor 维度超过 8 维 |
从错误码分布可以看出,参数层面的校验(空指针、类型不合法、类型不一致)在第一段接口即被拦截,而 shape 与维度相关的约束则在 tiling 阶段(错误码 561002,TILING_ERROR)才会暴露。
约束说明
- 确定性计算:
aclnnForeachPowScalarList默认为确定性实现,即相同输入在多次运行中产生一致的输出结果; - 输出
out不支持非连续 Tensor; scalars中指数取值绝对值必须小于等于 (2^31-1)。
调用示例与代码解读
以下示例代码来自 examples/test_aclnn_foreach_pow_scalar_list.cpp,与 API 文档中的示例一致,仅供参考。具体编译和执行过程可参考 编译与运行样例。
#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_foreach_pow_scalar_list.h"
#define CHECK_RET(cond, return_expr) \
do { \
if (!(cond)) { \
return_expr; \
} \
} while (0)
#define LOG_PRINT(message, ...) \
do { \
printf(message, ##__VA_ARGS__); \
} while (0)
int64_t GetShapeSize(const std::vector<int64_t>& shape) {
int64_t shapeSize = 1;
for (auto i : shape) {
shapeSize *= i;
}
return shapeSize;
}
int Init(int32_t deviceId, aclrtStream* stream) {
// 固定写法,资源初始化
auto ret = aclInit(nullptr);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret);
ret = aclrtSetDevice(deviceId);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret);
ret = aclrtCreateStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret);
return 0;
}
template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
aclDataType dataType, aclTensor** tensor) {
auto size = GetShapeSize(shape) * sizeof(T);
// 调用aclrtMalloc申请device侧内存
auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret);
// 调用aclrtMemcpy将host侧数据复制到device侧内存上
ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret);
// 计算连续tensor的strides
std::vector<int64_t> strides(shape.size(), 1);
for (int64_t i = shape.size() - 2; i >= 0; i--) {
strides[i] = shape[i + 1] * strides[i + 1];
}
// 调用aclCreateTensor接口创建aclTensor
*tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
shape.data(), shape.size(), *deviceAddr);
return 0;
}
int main() {
// 1. (固定写法)device/stream初始化,参考acl API手册
// 根据自己的实际device填写deviceId
int32_t deviceId = 0;
aclrtStream stream;
auto ret = Init(deviceId, &stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
// 2. 构造输入与输出,需要根据API的接口自定义构造
std::vector<int64_t> selfShape1 = {2, 3};
std::vector<int64_t> selfShape2 = {1, 3};
std::vector<int64_t> outShape1 = {2, 3};
std::vector<int64_t> outShape2 = {1, 3};
void* input1DeviceAddr = nullptr;
void* input2DeviceAddr = nullptr;
void* out1DeviceAddr = nullptr;
void* out2DeviceAddr = nullptr;
aclTensor* input1 = nullptr;
aclTensor* input2 = nullptr;
aclScalar* alpha1 = nullptr;
aclScalar* alpha2 = nullptr;
aclTensor* out1 = nullptr;
aclTensor* out2 = nullptr;
std::vector<float> input1HostData = {1, 2, 3, 4, 5, 6};
std::vector<float> input2HostData = {7, 8, 9};
std::vector<float> out1HostData(6, 0);
std::vector<float> out2HostData(3, 0);
float alpha1Value = 1.2f;
float alpha2Value = 2.2f;
// 创建input1 aclTensor
ret = CreateAclTensor(input1HostData, selfShape1, &input1DeviceAddr, aclDataType::ACL_FLOAT, &input1);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// 创建input2 aclTensor
ret = CreateAclTensor(input2HostData, selfShape2, &input2DeviceAddr, aclDataType::ACL_FLOAT, &input2);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// 创建alpha1 aclScalar
alpha1 = aclCreateScalar(&alpha1Value, aclDataType::ACL_FLOAT);
CHECK_RET(alpha1 != nullptr, return ret);
// 创建alpha2 aclScalar
alpha2 = aclCreateScalar(&alpha2Value, aclDataType::ACL_FLOAT);
CHECK_RET(alpha2 != nullptr, return ret);
// 创建out1 aclTensor
ret = CreateAclTensor(out1HostData, outShape1, &out1DeviceAddr, aclDataType::ACL_FLOAT, &out1);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// 创建out2 aclTensor
ret = CreateAclTensor(out2HostData, outShape2, &out2DeviceAddr, aclDataType::ACL_FLOAT, &out2);
CHECK_RET(ret == ACL_SUCCESS, return ret);
std::vector<aclTensor*> tempInput{input1, input2};
aclTensorList* tensorListInput = aclCreateTensorList(tempInput.data(), tempInput.size());
std::vector<aclTensor*> tempOutput{out1, out2};
aclTensorList* tensorListOutput = aclCreateTensorList(tempOutput.data(), tempOutput.size());
std::vector<aclScalar*> tempscalar{alpha1, alpha2};
aclScalarList* scalarlist = aclCreateScalarList(tempscalar.data(), tempscalar.size());
// 3. 调用CANN算子库API,需要修改为具体的API名称
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
// 调用aclnnForeachPowScalarList第一段接口
ret = aclnnForeachPowScalarListGetWorkspaceSize(tensorListInput, scalarlist, tensorListOutput, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnForeachPowScalarListGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// 根据第一段接口计算出的workspaceSize申请device内存
void* workspaceAddr = nullptr;
if (workspaceSize > 0) {
ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
}
// 调用aclnnForeachPowScalarList第二段接口
ret = aclnnForeachPowScalarList(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnForeachPowScalarList failed. ERROR: %d\n", ret); return ret);
// 4. (固定写法)同步等待任务执行结束
ret = aclrtSynchronizeStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);
// 5. 获取输出的值,将device侧内存上的结果复制至host侧,需要根据具体API的接口定义修改
auto size = GetShapeSize(outShape1);
std::vector<float> out1Data(size, 0);
ret = aclrtMemcpy(out1Data.data(), out1Data.size() * sizeof(out1Data[0]), out1DeviceAddr,
size * sizeof(out1Data[0]), ACL_MEMCPY_DEVICE_TO_HOST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
for (int64_t i = 0; i < size; i++) {
LOG_PRINT("out1 result[%ld] is: %f\n", i, out1Data[i]);
}
size = GetShapeSize(outShape2);
std::vector<float> out2Data(size, 0);
ret = aclrtMemcpy(out2Data.data(), out2Data.size() * sizeof(out2Data[0]), out2DeviceAddr,
size * sizeof(out2Data[0]), ACL_MEMCPY_DEVICE_TO_HOST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
for (int64_t i = 0; i < size; i++) {
LOG_PRINT("out2 result[%ld] is: %f\n", i, out2Data[i]);
}
// 6. 释放aclTensor和aclScalar,需要根据具体API的接口定义修改
aclDestroyTensorList(tensorListInput);
aclDestroyTensorList(tensorListOutput);
aclDestroyScalarList(scalarlist);
// 7.释放device资源,需要根据具体API的接口定义修改
aclrtFree(input1DeviceAddr);
aclrtFree(input2DeviceAddr);
aclrtFree(out1DeviceAddr);
aclrtFree(out2DeviceAddr);
if (workspaceSize > 0) {
aclrtFree(workspaceAddr);
}
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}
该示例的核心流程可以归纳为七个步骤:
- 资源初始化:
aclInit→aclrtSetDevice→aclrtCreateStream,这是所有 aclnn 程序的固定写法; - 构造输入输出:通过
aclrtMalloc/aclrtMemcpy准备 Device 侧数据,用aclCreateTensor创建aclTensor,用aclCreateScalar创建aclScalar,再通过aclCreateTensorList与aclCreateScalarList组装成张量列表与标量列表。示例中为{1,2,3,4,5,6}与{7,8,9}两个底数张量分别配指数 1.2 与 2.2,即分别计算x^1.2与x^2.2; - 两段式调用:先调
GetWorkspaceSize获取 workspace 大小与 executor,按需aclrtMalloc申请 workspace,再调执行接口; - 同步等待:
aclrtSynchronizeStream确保算子执行完毕; - 结果回拷:将 Device 侧结果通过
aclrtMemcpy拷回 Host 并打印; - 释放列表资源:
aclDestroyTensorList、aclDestroyScalarList; - 释放 Device 资源:
aclrtFree、aclrtDestroyStream、aclrtResetDevice、aclFinalize。
底层实现原理:从 OpDef 到 AscendC Kernel
ForeachPowScalarList 算子在仓库中是一个完整的三段式算子工程,理解其源码有助于更准确地使用接口。
算子定义(OpDef)
foreach_pow_scalar_list_def.cpp 是算子的 Host 侧定义文件,核心内容如下:
- 输入
x为DYNAMIC动态输入(TensorList),数据类型支持DT_FLOAT16, DT_FLOAT, DT_INT32, DT_BF16,格式统一为FORMAT_ND,并开启AutoContiguous自动连续化; - 输入
scalars为ScalarList类型(REQUIRED必选参数),数据类型由DtypeTensor2Scalar从张量类型推导而来,即浮点输入对应 FLOAT32、整型输入对应 INT64,与 API 文档的数据类型对应关系完全一致; - 输出
y同样为DYNAMIC动态输出; - AI Core 配置上开启了
DynamicRankSupportFlag(支持动态维度)、DynamicShapeSupportFlag(支持动态 shape)、PrecisionReduceFlag(允许精度降低),并注册了 ascend950、ascend910_93、ascend910b、kirinx90、kirin9030 等平台配置。
Tiling 策略
arch35/foreach_pow_scalar_list_tiling_arch35.cpp 实现了 arch35 平台的 tiling 逻辑:
- 通过平台信息获取 AIV 核数
coreNum与 UB 内存大小ubSize; - 遍历
x中每个 Tensor 的 shape,累加得到总元素数totalElements,并记录每个 Tensor 的元素数到tensorElements[]; - 按"每个核至少处理
MIN_PER_CORE = 1024个元素"的原则计算所需核数needCoreNum = min(coreNum, ceil(totalElements / 1024)),并通过SetBlockDim设置实际并行核数;当totalElements == 0时退化为单核执行; - 通过
GetLibApiWorkSpaceSize获取系统 workspace 大小,并申请用户 workspace; - 根据
x的数据类型(FLOAT/FLOAT16/INT32/BF16)设置不同的 tiling key,kernel 侧据此选择对应的实例化模板; - 校验张量数量上限为
MAX_TENSOR_NUM = 256。
tiling 数据结构定义在 arch35/foreach_pow_scalar_list_tiling_data.h,包含 needCoreNum、tensorCount、totalElements 以及最多 256 个 Tensor 的元素数数组 tensorElements[256]。
AscendC Kernel 实现
kernel 入口在 op_kernel/foreach_pow_scalar_list.cpp,根据 tiling key 分发到不同数据类型的模板实例:TILING_KEY 1/2/3/4 分别对应 half、float、int、bfloat16_t,其中 BF16 分支在 __NPU_ARCH__ == 3003 || 3113 架构下被排除(与 Kirin 平台不支持 BF16 的限制对应)。
核心计算类 ForeachPowScalarListND<T> 定义在 op_kernel/foreach_pow_scalar_list.h,实现要点:
- 多核切分:kernel 通过
GetBlockIdx()获取当前核号,从 tiling 数据中解析出本核负责的 Tensor 区间[tensorStart, tensorEnd]及每个 Tensor 内部的起始/结束偏移,实现"整 Tensor 级 + 区间级"两级负载划分; - 双缓冲流水:使用
BUFFER_NUM = 2的双缓冲队列(dataQueue/outQueue),CopyIn通过DataCopy(整块)或DataCopyPad(余数块)将 Global Memory 数据搬入 UB,ComputeAndCopyOut计算完毕后异步拷回 Global Memory,实现搬入-计算-搬出的流水重叠; - 逐 Tensor 处理:
Process()循环遍历本核负责的每个 Tensor,从inScalarGM读取该 Tensor 对应的标量值,再调用SingleTensorProcess按maxDataCount分块批量处理; - BF16 精度处理:由于 AscendC 向量指令的幂运算
Power支持 float/half 等类型,InnerComputer<bfloat16_t>采用特化实现——先将 BF16 数据Cast到 float 计算(RoundMode::CAST_NONE),完成Power<float>后再以RoundMode::CAST_RINT舍入转回 BF16 写出,从而保证计算精度; - Scalar 读取:每个 Tensor 的指数通过
inScalarGM.GetValue(i)从标量列表内存中按下标取出,浮点类型直接强转为模板类型,BF16 则转为 float 参与计算。
图模式调用
除了 aclnn 接口,该算子还支持图模式调用。通过算子 IR 中 REG_OP(ForeachPowScalarList) 注册的 DYNAMIC_INPUT(x)、INPUT(scalars)、DYNAMIC_OUTPUT(y) 构图方式即可接入 Graph 引擎,两种调用方式在 README 的"调用说明"一节中有明确对照。
测试与验证
仓库为该算子配备了完整的测试体系,可用于验证接口行为与计算正确性。
UT 单测(tests/ut/op_kernel/test_foreach_pow_scalar_list.cpp)通过 ICPU 模式直接运行 kernel:针对 float32、float16、int32 等数据类型,构造 {{128,64},{16,128},{32,128}} 三张不同 shape 的 Tensor 列表,由 gen_data.py 生成输入数据、compare_data.py 对比输出,验证各数据类型的计算结果。
ATK 系统测试(tests/st/aclnnForeachPowScalarList/executor_aclnnForeachPowScalarList.py)以 PyTorch 的 torch._foreach_pow(x, scalars) 作为对标基准,注册 function_aclnnForeachPowScalarList 执行器;atk_aclnnForeachPowScalarList.json 中声明了 200 组覆盖 fp16/fp32/bf16/int32 数据类型、从 1 维到 8 维、单 Tensor 到多 Tensor 列表、标量取值范围 0~5 的用例矩阵,例如 bf16 的 [1,3,1]、int32 的 [1,1,2] 等多维组合,从系统层面验证 aclnn 接口与 PyTorch 语义的一致性。
总结
ForeachPowScalarList 是 CANN ops-nn 中用于批量幂运算的 foreach 系列算子,通过 aclnn 两段式接口对外提供调用能力。使用时需要重点关注:输入与输出数据类型的对应关系(浮点输入配 FLOAT32 标量、INT32 输入配 INT64 标量)、指数绝对值不超过 (2^31-1) 的取值约束、输出不支持非连续 Tensor、Tensor 维度不超过 8 维,以及不同产品(尤其 Kirin 平台不支持 BF16)的能力差异。其底层通过多核 tiling 切分、UB 双缓冲流水和 BF16 升精度计算等机制保证执行效率与精度,并通过 UT 与 ATK 双层测试与 PyTorch 语义对齐。