CANN ops-math 算子开发实战:Tanh 激活算子的 aclnnTanh 与 aclnnInplaceTanh 调用指南
CANN ops-math 算子开发实战:Tanh 激活算子的 aclnnTanh 与 aclnnInplaceTanh 调用指南
导读
本文以 CANN ops-math 数学算子库中的 Tanh 算子为切入点,系统讲解该激活算子的产品支持情况、数学定义、输入输出参数约束,以及基于 aclnn 单算子 API 的 aclnnTanh 与 aclnnInplaceTanh 两段式调用流程。读完本文,你将掌握 Tanh 算子在 Ascend NPU 上的完整调用方法(含可直接编译运行的 C++ 示例),并能结合算子源码理解其参数校验、数据流与 Kernel 实现原理。
算子总览
Tanh(双曲正切)是一个 elementwise(逐元素)激活函数算子:它对输入 tensor 的每个元素独立计算 tanh 值,输出与输入具有相同 shape 的 tensor。该算子位于仓库 math/tanh 目录,同时提供 aclnn 单算子接口(aclnnTanh / aclnnInplaceTanh)、GE 图算子注册(math/tanh/op_graph/tanh_proto.h)与 TF 插件适配(math/tanh/framework/tanh_tf_plugin.cpp),从源码结构看,其官方定位与 TensorFlow 的 Tanh 算子保持兼容。
产品支持情况
Tanh 算子在不同硬件产品上的支持情况如下表所示:
| 产品 | 是否支持 |
|---|---|
| Ascend 950PR/Ascend 950DT | √ |
| Atlas A3 训练系列产品/Atlas A3 推理系列产品 | √ |
| Atlas A2 训练系列产品/Atlas A2 推理系列产品 | √ |
| Atlas 200I/500 A2 推理产品 | × |
| Atlas 推理系列产品 | × |
| Atlas 训练系列产品 | √ |
这一支持矩阵与 op_api 层源码中的平台判断逻辑相互印证:在 math/tanh/op_api/aclnn_tanh.cpp 中,GetOutDtypeSupportList() 依据当前 NPU 架构(NpuArch::DAV_2201 或寄存器基架构)区分不同产品支持的数据类型列表,aiconfig 中则通过 math/tanh/op_host/config/ascend950/tanh_binary.json 等配置文件登记各产品的 binary 部署信息。
功能说明与计算公式
算子功能:激活函数。返回与输入 tensor shape 相同的 tensor,对输入 tensor 进行 elementwise 计算。
计算公式:
即对输入 self 中第 i 个元素 self_i 计算 out_i = tanh(self_i)。tanh 的输出值域为 (-1, 1),在神经网络中常作为隐藏层激活函数或门控单元的一部分使用。
参数说明
Tanh 算子的输入输出参数如下:
| 参数名 | 输入/输出/属性 | 描述 | 数据类型 | 数据格式 |
|---|---|---|---|---|
| self | 输入 | 待进行 tanh 计算的入参,公式中的 self_i。 | FLOAT、FLOAT16、BOOL、UINT8、INT8、INT16、INT32、INT64、BFLOAT16 | ND |
| out | 输出 | 待进行 tanh 计算的出参,公式中的 out_i。 | FLOAT、FLOAT16、BFLOAT16 | ND |
约束说明:
- Atlas 训练系列产品、Atlas 推理系列产品:不支持 BFLOAT16。
需要说明的是,"输入支持 BOOL/整型" 这一能力来自 aclnn API 层的类型扩展:从 math/tanh/op_api/aclnn_tanh.cpp 的实现看,aclnn 接口将 BOOL、UINT8、INT8、INT16、INT32、INT64 等类型(DTYPE_CAST_LIST)在计算前统一通过 l0op::Cast 转换为 FLOAT 参与 tanh 计算,因此底层 Kernel 实际只处理 FLOAT/FLOAT16/BFLOAT16 三种浮点类型,这也与 math/tanh/op_host/tanh_def.cpp 中算子原语定义(ge::DT_BF16, ge::DT_FLOAT16, ge::DT_FLOAT)一致。
图算子层的输入输出约束
在 GE 图算子定义中,Tanh 的输入输出通过 UnaryDataType() 声明(见 math/tanh/op_graph/tanh_proto.h),shape 推导使用 elementwise 通用推导规则(见 math/tanh/op_host/tanh_infershape.cpp),即输出 shape 与输入保持一致。在 tiling 阶段,math/tanh/op_host/arch35/tanh_tiling_arch35.cpp 会进一步校验输入输出 dtype 相同且 shape 一致,并计算 workspace 大小与 block 维度。
调用说明
Tanh 算子支持通过 aclnn 单算子 API 调用,官方调用样例位于 math/tanh/examples/test_aclnn_tanh.cpp,接口级文档详见 math/tanh/docs/aclnnTanh&aclnnInplaceTanh.md。
| 调用方式 | 调用样例 | 说明 |
|---|---|---|
| aclnn 调用 | test_aclnn_tanh | 通过 aclnnTanh/aclnnInplaceTanh 接口方式调用 Tanh 算子。 |
aclnnTanh 与 aclnnInplaceTanh 的区别
aclnnTanh 与 aclnnInplaceTanh 实现相同的数学功能,使用区别如下,请根据自身实际场景选择合适的算子:
- aclnnTanh:需新建一个输出张量对象(out)存储计算结果,原输入张量保持不变。
- aclnnInplaceTanh:无需新建输出张量对象,直接在输入张量(selfRef)的内存中就地写入计算结果,可省去输出张量的内存申请,适合允许原地覆盖输入的场景。
两段式接口调用范式
按照 CANN 单算子 API 的统一规范,每个算子采用两段式接口调用:必须先调用第一段接口(aclnnTanhGetWorkspaceSize 或 aclnnInplaceTanhGetWorkspaceSize)获取计算所需 workspace 大小以及包含算子计算流程的执行器(executor),再按照该大小申请 NPU 侧 workspace 内存,最后调用第二段接口(aclnnTanh 或 aclnnInplaceTanh)执行计算。其中 workspace 是指除输入/输出外,算子在 NPU 上完成计算所需的临时内存。第二段接口不能重复调用,每次执行都需要重新走完两段流程。
四个接口的函数原型如下:
aclnnStatus aclnnTanhGetWorkspaceSize(
const aclTensor* self,
aclTensor* out,
uint64_t* workspaceSize,
aclOpExecutor** executor)
aclnnStatus aclnnTanh(
void* workspace,
uint64_t workspaceSize,
aclOpExecutor* executor,
const aclrtStream stream)
aclnnStatus aclnnInplaceTanhGetWorkspaceSize(
aclTensor* selfRef,
uint64_t* workspaceSize,
aclOpExecutor** executor)
aclnnStatus aclnnInplaceTanh(
void* workspace,
uint64_t workspaceSize,
aclOpExecutor* executor,
const aclrtStream stream)
aclnnTanhGetWorkspaceSize 参数说明
| 参数名 | 输入/输出 | 描述 | 使用说明 | 数据类型 | 数据格式 | 维度(shape) | 非连续 Tensor |
|---|---|---|---|---|---|---|---|
| self(aclTensor*) | 输入 | 公式中的输入 self。 | shape 需要与 out 一致,和 out 的数据类型满足互推导关系。 | FLOAT、FLOAT16、BOOL、UINT8、INT8、INT16、INT32、INT64、BFLOAT16 | ND | 不大于 8 | √ |
| out(aclTensor*) | 输出 | 公式中的 out。 | shape 需要与 self 一致,和 self 的数据类型满足互推导关系。 | FLOAT、FLOAT16、BFLOAT16 | ND | - | √ |
| workspaceSize(uint64_t*) | 输出 | 返回需要在 Device 侧申请的 workspace 大小。 | - | - | - | - | - |
| executor(aclOpExecutor**) | 输出 | 返回 op 执行器,包含了算子计算流程。 | - | - | - | - | - |
说明:Atlas 训练系列产品不支持 BFLOAT16。
返回值:aclnnStatus,返回状态码,具体参见 aclnn 返回码。
第一段接口完成入参校验,出现以下场景时报错:
| 返回值 | 错误码 | 描述 |
|---|---|---|
| ACLNN_ERR_PARAM_NULLPTR | 161001 | 传入的 self 或 out 是空指针。 |
| ACLNN_ERR_PARAM_INVALID | 161002 | self 和 out 的数据类型和数据格式不在支持的范围之内。 |
| ACLNN_ERR_PARAM_INVALID | 161002 | self 和 out 的数据类型不满足互推导关系。 |
| ACLNN_ERR_PARAM_INVALID | 161002 | self 和 out 的维度大于 8。 |
| ACLNN_ERR_PARAM_INVALID | 161002 | self 和 out 的 shape 不一致。 |
aclnnTanh 参数说明
| 参数名 | 输入/输出 | 描述 |
|---|---|---|
| workspace | 输入 | 在 Device 侧申请的 workspace 内存地址。 |
| workspaceSize | 输入 | 在 Device 侧申请的 workspace 大小,由第一段接口 aclnnTanhGetWorkspaceSize 获取。 |
| executor | 输入 | op 执行器,包含了算子计算流程。 |
| stream | 输入 | 指定执行任务的 Stream。 |
返回值:aclnnStatus,返回状态码,具体参见 aclnn 返回码。
aclnnInplaceTanhGetWorkspaceSize 参数说明
| 参数名 | 输入/输出 | 描述 | 使用说明 | 数据类型 | 数据格式 | 维度(shape) | 非连续 Tensor |
|---|---|---|---|---|---|---|---|
| selfRef(aclTensor*) | 输入/输出 | 公式中的 self。 | - | FLOAT、FLOAT16、BFLOAT16 | ND | 不大于 8 | √ |
| workspaceSize(uint64_t*) | 输出 | 返回需要在 Device 侧申请的 workspace 大小。 | - | - | - | - | - |
| executor(aclOpExecutor**) | 输出 | 返回 op 执行器,包含了算子计算流程。 | - | - | - | - | - |
说明:Atlas 训练系列产品不支持 BFLOAT16。
返回值:aclnnStatus,返回状态码,具体参见 aclnn 返回码。
第一段接口完成入参校验,出现以下场景时报错:
| 返回值 | 错误码 | 描述 |
|---|---|---|
| ACLNN_ERR_PARAM_NULLPTR | 161001 | 传入的 selfRef 是空指针。 |
| ACLNN_ERR_PARAM_INVALID | 161002 | selfRef 的数据类型不在支持的范围之内。 |
aclnnInplaceTanh 参数说明
| 参数名 | 输入/输出 | 描述 |
|---|---|---|
| workspace | 输入 | 在 Device 侧申请的 workspace 内存地址。 |
| workspaceSize | 输入 | 在 Device 侧申请的 workspace 大小,由第一段接口 aclnnInplaceTanhGetWorkspaceSize 获取。 |
| executor | 输入 | op 执行器,包含了算子计算流程。 |
| stream | 输入 | 指定执行任务的 Stream。 |
返回值:aclnnStatus,返回状态码,具体参见 aclnn 返回码。
确定性约束
- 确定性计算:aclnnTanh & aclnnInplaceTanh 默认确定性实现,即相同输入多次执行结果一致,不受随机因素影响。
调用示例:完整可运行的 C++ 样例
以下示例代码摘自 math/tanh/examples/test_aclnn_tanh.cpp,在同一个程序中依次演示了 aclnnTanh(非 inplace)与 aclnnInplaceTanh(inplace)的完整调用流程。示例中使用智能指针管理 device 内存与 aclTensor 生命周期,编译与执行的整体流程请参考编译与运行样例。
#include <iostream>
#include <memory>
#include <type_traits>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_tanh.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;
}
using StreamPtr = std::unique_ptr<std::remove_pointer<aclrtStream>::type, decltype(&aclrtDestroyStream)>;
using DeviceMemPtr = std::unique_ptr<void, decltype(&aclrtFree)>;
using TensorPtr = std::unique_ptr<aclTensor, decltype(&aclDestroyTensor)>;
int Init(int32_t deviceId, StreamPtr& stream, bool& initialized, bool& deviceSet)
{
// 固定写法,资源初始化
auto ret = aclInit(nullptr);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret);
initialized = true;
ret = aclrtSetDevice(deviceId);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret);
deviceSet = true;
aclrtStream rawStream = nullptr;
ret = aclrtCreateStream(&rawStream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret);
stream.reset(rawStream);
return 0;
}
template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, aclDataType dataType,
DeviceMemPtr& deviceAddr, TensorPtr& tensor)
{
auto size = GetShapeSize(shape) * sizeof(T);
void* rawDeviceAddr = nullptr;
// 调用aclrtMalloc申请device侧内存
auto ret = aclrtMalloc(&rawDeviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret);
deviceAddr.reset(rawDeviceAddr);
// 调用aclrtMemcpy将host侧数据拷贝到device侧内存上
ret = aclrtMemcpy(deviceAddr.get(), 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
aclTensor* rawTensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0,
aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), deviceAddr.get());
CHECK_RET(rawTensor != nullptr, LOG_PRINT("aclCreateTensor failed.\n"); return ACL_ERROR_FAILURE);
tensor.reset(rawTensor);
return 0;
}
int main()
{
// 1. (固定写法)device/stream初始化,参考acl API手册
// 根据自己的实际device填写deviceId
int32_t deviceId = 0;
bool initialized = false;
bool deviceSet = false;
std::shared_ptr<void> aclGuard(nullptr, & {
if (deviceSet) {
aclrtResetDevice(deviceId);
}
if (initialized) {
aclFinalize();
}
});
StreamPtr stream(nullptr, &aclrtDestroyStream);
auto ret = Init(deviceId, stream, initialized, deviceSet);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
// 2. 构造输入与输出,需要根据API的接口自定义构造
std::vector<int64_t> selfShape = {2, 2};
std::vector<int64_t> outShape = {2, 2};
DeviceMemPtr selfDeviceAddr(nullptr, &aclrtFree);
DeviceMemPtr outDeviceAddr(nullptr, &aclrtFree);
TensorPtr self(nullptr, &aclDestroyTensor);
TensorPtr out(nullptr, &aclDestroyTensor);
std::vector<float> selfHostData = {0, 1, 2, 3};
std::vector<float> outHostData = {0, 0, 0, 0};
// 创建self aclTensor
ret = CreateAclTensor(selfHostData, selfShape, aclDataType::ACL_FLOAT, selfDeviceAddr, self);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// 创建out aclTensor
ret = CreateAclTensor(outHostData, outShape, aclDataType::ACL_FLOAT, outDeviceAddr, out);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// 3. 调用CANN算子库API,需要修改为具体的API名称
// aclnnTanh接口调用示例
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
// 调用aclnnTanh第一段接口
ret = aclnnTanhGetWorkspaceSize(self.get(), out.get(), &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnTanhGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// 根据第一段接口计算出的workspaceSize申请device内存
DeviceMemPtr workspaceAddr(nullptr, &aclrtFree);
if (workspaceSize > static_cast<uint64_t>(0)) {
void* rawWorkspaceAddr = nullptr;
ret = aclrtMalloc(&rawWorkspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
workspaceAddr.reset(rawWorkspaceAddr);
}
// 调用aclnnTanh第二段接口
ret = aclnnTanh(workspaceAddr.get(), workspaceSize, executor, stream.get());
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnTanh failed. ERROR: %d\n", ret); return ret);
// aclnnInplaceTanh接口调用示例
uint64_t inplaceWorkspaceSize = 0;
aclOpExecutor* inplaceExecutor;
// 调用aclnnInplaceTanh第一段接口
ret = aclnnInplaceTanhGetWorkspaceSize(self.get(), &inplaceWorkspaceSize, &inplaceExecutor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceTanhGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// 根据第一段接口计算出的workspaceSize申请device内存
DeviceMemPtr inplaceWorkspaceAddr(nullptr, &aclrtFree);
if (inplaceWorkspaceSize > static_cast<uint64_t>(0)) {
void* rawInplaceWorkspaceAddr = nullptr;
ret = aclrtMalloc(&rawInplaceWorkspaceAddr, inplaceWorkspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
inplaceWorkspaceAddr.reset(rawInplaceWorkspaceAddr);
}
// 调用aclnnInplaceTanh第二段接口
ret = aclnnInplaceTanh(inplaceWorkspaceAddr.get(), inplaceWorkspaceSize, inplaceExecutor, stream.get());
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceTanh failed. ERROR: %d\n", ret); return ret);
// 4. (固定写法)同步等待任务执行结束
ret = aclrtSynchronizeStream(stream.get());
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);
// 5. 获取输出的值,将device侧内存上的结果拷贝至host侧,需要根据具体API的接口定义修改
auto size = GetShapeSize(outShape);
std::vector<float> resultData(size, 0);
ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr.get(),
size * sizeof(resultData[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("aclnnTanh result[%ld] is: %f\n", i, resultData[i]);
}
auto inplaceSize = GetShapeSize(selfShape);
std::vector<float> inplaceResultData(inplaceSize, 0);
ret = aclrtMemcpy(inplaceResultData.data(), inplaceResultData.size() * sizeof(inplaceResultData[0]),
selfDeviceAddr.get(), inplaceSize * sizeof(inplaceResultData[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 < inplaceSize; i++) {
LOG_PRINT("aclnnInplaceTanh result[%ld] is: %f\n", i, inplaceResultData[i]);
}
return 0;
}
对输入 {0, 1, 2, 3},理论上 aclnnTanh 与 aclnnInplaceTanh 输出的结果应分别为 {0, 0.7616, 0.9640, 0.9951} 左右(inplace 结果直接写回 self 内存)。示例第 1 步与第 4 步为 acl 初始化与同步的固定写法,第 6、7 步资源释放借助 RAII 智能指针自动完成。
源码级原理深挖
API 层的参数校验与计算流程
aclnnTanh 的底层实现位于 math/tanh/op_api/aclnn_tanh.cpp,其中 CheckParams 按顺序执行四类校验,与文档中的报错表一一对应:
- 空指针校验(
CheckNotNull):self 或 out 为空时返回ACLNN_ERR_PARAM_NULLPTR(错误码 161001)。 - 数据类型校验(
CheckDtypeValid):依据当前 NPU 架构从ASCEND910_DTYPE_SUPPORT_LIST(8 种类型,不含 BF16)与ASCEND910B_DTYPE_SUPPORT_LIST(9 种类型,含 BF16)中选择支持列表;整型输入(IsIntegralType)会被视为可转换为 FLOAT 的类型参与结果推导。 - 格式校验(
CheckFormat):输入输出 view format 必须一致,私有格式直接报错,非 ND 的存储格式打印 warning 日志(文档声明仅支持 ND)。 - shape 校验(
CheckShape):通过OP_CHECK_MAX_DIM限制维度不大于MAX_SUPPORT_DIMS_NUMS(8),并要求输入输出 shape 一致。
校验通过后,ExecTanhGetWorkspaceSize 在 API 层构造计算图,其计算路径为(与 math/tanh/op_api/aclnn_tanh.h 中的 mermaid 图一致):
self → L0::Contiguous → L0::Tanh → L0::Cast → L0::ViewCopy → out
- 输入先经
l0op::Contiguous转成连续 tensor(因此支持非连续输入); - BOOL 与整型经
l0op::Cast转成 FLOAT 参与计算; l0op::Tanh完成核心计算;- 结果再
l0op::Cast回输出 dtype,最后l0op::ViewCopy拷贝到可能非连续的 out 上。 - 空 tensor 直接返回,workspaceSize 置 0。
aclnnInplaceTanhGetWorkspaceSize 则先校验 selfRef 数据类型必须在 GetOutDtypeSupportList()(FLOAT、FLOAT16、BFLOAT16)范围内,然后把 selfRef 同时作为输入输出,复用同一套 ExecTanhGetWorkspaceSize 计算流程。第二段接口 aclnnTanh / aclnnInplaceTanh 统一调用 CommonOpExecutorRun 驱动执行器完成计算。
Tiling 与 Kernel 实现
- 算子原语定义(math/tanh/op_host/tanh_def.cpp):声明输入 x、输出 y 仅支持
DT_BF16 / DT_FLOAT16 / DT_FLOAT与 ND 格式,开启动态 shape、动态 rank 支持,并注册 ascend950/ascend350 两个平台的 AICore 配置。 - shape 推导(math/tanh/op_host/tanh_infershape.cpp):直接复用
Ops::Base::InferShape4Elewise,保证输出与输入 shape 一致。 - tiling(math/tanh/op_host/arch35/tanh_tiling_arch35.cpp):校验输入 dtype(仅允许 FLOAT16/BF16/FLOAT)与输入输出 shape 一致后,调用平台库计算 workspace 大小、设置 tiling key 与 block 数。
- Kernel 计算(math/tanh/op_kernel/tanh_apt.cpp 与 math/tanh/op_kernel/arch35/tanh_dag.h):Kernel 以
ElementwiseSch调度 DAG,核心计算TanhCoreCompute采用"多项式逼近 + 指数修正"的混合实现:- 对 |x| < 0.6 的区间,用 5 次多项式
p(x) = x·(1 + x²·(0.133152977 + x²·(-0.333327681 + 0.0157396831·x²))·(-0.0523039624 + x²·…))近似; - 对 |x| ≥ 0.6 的区间,改用
tanh(x) = sign(x)·(1 - 2/(e^{2|x|}+1))的指数形式精确计算; - 对 |x| ≥ 9.0109138(
FP32_SAT_BOUND)直接饱和输出 ±1,并利用符号掩码恢复符号。FLOAT16/BFLOAT16 输入会在计算前扩展为 FLOAT,计算后再压缩回原精度。
- 对 |x| < 0.6 的区间,用 5 次多项式
测试与验证
仓库为 Tanh 算子提供了多层测试覆盖:
- tiling 单测:math/tanh/tests/ut/op_host/arch35/test_tanh_tiling.cpp 对 FLOAT16/BFLOAT16/FLOAT 等 dtype、
{1,64,2,64}shape、ND 格式验证 tiling key 与 workspace 大小是否符合预期; - API 层单测:math/tanh/tests/ut/op_api/test_aclnn_tanh.cpp 验证 aclnnTanh 接口的调用正确性;
- ST 用例与 golden 数据:math/tanh/tests/st/atk_aclnnTanh.json、math/tanh/tests/st/arch35/ttk_kernel_tanh_st.csv 与 math/tanh/tests/assets/golden.py 共同构成端到端的算子正确性验证。