CANN ops-math 算子开发实战:Tanh 激活算子的 aclnnTanh 与 aclnnInplaceTanh 调用指南

原创2026-09-21 13:09:521,906 阅读
文章标签:算子库人工智能深度学习高性能计算CANNAscend

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 计算。

计算公式:

tanh(self)=eself−e−selfeself+e−selftanh(self)=\frac{e^{self}-e^{-self}}{e^{self} + e^{-self}}

即对输入 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 按顺序执行四类校验,与文档中的报错表一一对应:

  1. 空指针校验(CheckNotNull):self 或 out 为空时返回 ACLNN_ERR_PARAM_NULLPTR(错误码 161001)。
  2. 数据类型校验(CheckDtypeValid):依据当前 NPU 架构从 ASCEND910_DTYPE_SUPPORT_LIST(8 种类型,不含 BF16)与 ASCEND910B_DTYPE_SUPPORT_LIST(9 种类型,含 BF16)中选择支持列表;整型输入(IsIntegralType)会被视为可转换为 FLOAT 的类型参与结果推导。
  3. 格式校验(CheckFormat):输入输出 view format 必须一致,私有格式直接报错,非 ND 的存储格式打印 warning 日志(文档声明仅支持 ND)。
  4. 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,计算后再压缩回原精度。

测试与验证

仓库为 Tanh 算子提供了多层测试覆盖:

相关阅读

登录后查看全文
ops-math