现象

aclnnInplaceLog2 的 COMPLEX128 路径只在 float32 级精度上计算：实测相对误差恒为 ~2.75e-9（≈28 bit 有效位），而 fp64 目标应达 ~1e-16。100% 复现。

同机、同调用方式的对照：本接口 FLOAT64 逐位相等（max abs_err = 0）；aclnnSqrt+COMPLEX128 与 double 参考逐位一致；CPU torch.log2(complex128) 逐位一致；本接口 COMPLEX64 相对误差 ~1e-7（符合 fp32，正常）。只有 COMPLEX128 掉到 28 bit。

批量验证：237 条 COMPLEX128 用例里 231 条可给出相对误差，231/231 都等于 2.7478e-9——算法定标问题，非个别值抖动。

期望

资料参数表把 COMPLEX128 列为 selfRef 支持类型；它即 64 位浮点复数，log2 应以 double 精度计算 —— 同接口 FLOAT64 与同机 aclnnSqrt 都做到了逐位一致。

环境

• 硬件：Atlas A2 训练系列（Ascend 910B2）；软件：CANN 9.2.0；代码：cann/ops-math master 21848df4（本机工作副本 5eaca2328，math/log）
• 调用方式：aclnn 两段式 C 直调（aclnnInplaceLog2GetWorkspaceSize + aclnnInplaceLog2），不经 torch
• 编译：g++ -std=c++17 -O2 repro.cpp -I$ASCEND_HOME/include -I$ASCEND_HOME/include/aclnnop -L$ASCEND_HOME/lib64 -L$ASCEND_HOME/runtime/lib64 -lascendcl -lnnopbase -lopapi -lopapi_math

复现步骤

1. 把下面代码块存成 repro.cpp，用上面那条 g++ 命令编译（$ASCEND_HOME 指向本机 CANN 安装目录）。
2. ./a.out。
3. 看 [缺陷组 COMPLEX128] max|abs_err|：应为 0，实测 7.30e-08。
4. 看 [对照组 FLOAT64] max|abs_err|：实测 0，证明同接口 fp64 路径无精度损失。

复现脚本

#include <acl/acl.h>
#include "aclnnop/aclnn_log2.h"
#include <cmath>
#include <complex>
#include <cstdio>
#include <vector>
static double run(const std::vector<double>& host, aclDataType dt, bool complex_,
                  aclrtStream stream, int* ret1, int* ret2) {
    size_t elems = complex_ ? host.size() / 2 : host.size();
    std::vector<int64_t> shape{(int64_t)elems};
    void* dev = nullptr;
    aclrtMalloc(&dev, host.size() * sizeof(double), ACL_MEM_MALLOC_HUGE_FIRST);
    aclrtMemcpy(dev, host.size() * sizeof(double), host.data(), host.size() * sizeof(double),
                ACL_MEMCPY_HOST_TO_DEVICE);
    aclTensor* t = aclCreateTensor(shape.data(), 1, dt, nullptr, 0, ACL_FORMAT_ND,
                                   shape.data(), 1, dev);
    uint64_t ws = 0;
    aclOpExecutor* ex = nullptr;
    *ret1 = (int)aclnnInplaceLog2GetWorkspaceSize(t, &ws, &ex);
    void* wsp = nullptr;
    if (*ret1 == 0) {
        if (ws > 0) aclrtMalloc(&wsp, ws, ACL_MEM_MALLOC_HUGE_FIRST);
        *ret2 = (int)aclnnInplaceLog2(wsp, ws, ex, stream);
        if (*ret2 == 0) aclrtSynchronizeStream(stream);
    }
    std::vector<double> back(host.size());
    aclrtMemcpy(back.data(), host.size() * sizeof(double), dev, host.size() * sizeof(double),
                ACL_MEMCPY_DEVICE_TO_HOST);
    double maxerr = 0.0;
    for (size_t i = 0; i < elems; ++i) {
        double got = back[complex_ ? 2 * i : i];
        double exp;
        if (complex_) {
            std::complex<double> z(host[2 * i], host[2 * i + 1]);
            exp = (std::log(z) / std::log(2.0)).real();
        } else {
            exp = std::log2(host[i]);
        }
        double e = std::fabs(got - exp);
        printf("  in=%-12.6g expect=%.17g actual=%.17g abs_err=%.3g\n",
               host[complex_ ? 2 * i : i], exp, got, e);
        if (e > maxerr) maxerr = e;
    }
    aclDestroyTensor(t);
    aclrtFree(dev);
    if (wsp) aclrtFree(wsp);
    return maxerr;
}
int main() {
    if (aclInit(nullptr) != ACL_SUCCESS) return 2;
    if (aclrtSetDevice(0) != ACL_SUCCESS) return 2;
    aclrtStream stream = nullptr;
    if (aclrtCreateStream(&stream) != ACL_SUCCESS) return 2;
    int r1 = 0, r2 = 0;
    printf("[缺陷组 COMPLEX128 log2]\n");
    double bad = run({2.0, 0.0, 10.0, 0.0, 1e8, 0.0}, ACL_COMPLEX128, true, stream, &r1, &r2);
    printf("[缺陷组 COMPLEX128] max|abs_err| = %.6e  (ret=%d/%d)\n", bad, r1, r2);
    printf("[对照组 FLOAT64 log2(2^k)]\n");
    double ctl = run({2.0, 4.0, 8.0, 1024.0}, ACL_DOUBLE, false, stream, &r1, &r2);
    printf("[对照组 FLOAT64] max|abs_err| = %.6e  (ret=%d/%d)\n", ctl, r1, r2);
    aclrtDestroyStream(stream);
    aclrtResetDevice(0);
    aclFinalize();
    return bad > 0 ? 1 : 0;
}

实测输出（本机实跑）：

[缺陷组 COMPLEX128 log2]
  in=2     expect=1 actual=0.99999999725216471 abs_err=2.75e-09
  in=1e+08 expect=26.575424759098901 actual=26.575424686074012 abs_err=7.3e-08
[缺陷组 COMPLEX128] max|abs_err| = 7.302489e-08  (ret=0/0)
[对照组 FLOAT64] max|abs_err| = 0.000000e+00  (ret=0/0)

影响

1. COMPLEX128 做 log2 的链路（复对数、频谱/相位分析、复域归一化）带入 1e-9 级误差，比应有的 1e-16 差 7 个数量级，再进迭代/求导会放大成可见偏差。
2. 误差是系统性常数偏差，多次平均消不掉；用户按资料选 COMPLEX128 正是要高精度，实际被静默降精度。

建议

1. 核查 COMPLEX128 分支：从特征看更像在 float32 上求 log/log2 再升到 double；若 A2 上确为 fp32 实现，请改为 double 路径。
2. 若短期不能修，请在资料「约束说明」写明 COMPLEX128 的实际精度等级；并补 UT/ST：log2(2+0i) == 1、log2(10+0i) 与 fp64 参考在 1e-14 内。