Closed
[Bug-Report|缺陷反馈]: aclnnForeachNorm 的 p 非 1/2 时静默返回错误阶数范数(p=3 返 L2、p=1.5 返 L1,两段均返 0) #8012
liuhanwen8Add on  19 days agoClosed at  8 days ago
liuhanwen8
liuhanwen8
19 days ago Create

1)问题描述

aclnnForeachNorm 的第二个入参 scalar 是范数阶数 p。资料(foreach/foreach_norm/docs/aclnnForeachNorm.md,A2/A3 段)给出的公式是通用形式:

y_i = (Σ|x_i|^p)^(1/p)

实测:只有 p ∈ {1, 2} 正确,其余 p 全部静默返回 p=1 或 p=2 的结果,两段返回码都是 0。

同一份输入、同一进程内连续调用:

p 资料公式值 设备实测 out[0] 结论
1 249.809 249.809 ✅ 正确
1.5 31.930 249.809 ❌ 与 p=1 完全相同(落 p=1 分支)
2 11.527 11.5266 ✅ 正确
2.5 6.2976 11.5266 ❌ 与 p=2 完全相同
3 4.2297 11.5266 ❌ 与 p=2 完全相同
0.5 124923 11.5266 ❌ 差 1 万倍
+inf max|x| = 0.744845 11.5266 ❌
-inf min|x| = 0.25 11.5266 ❌
nan 未定义(PyTorch 给 nan) 11.5266(有限值) ❌

输入 x = fp32[16x32],取值 0.25 + 0.5*(i%97)/97(全正,无 inf/nan),结果只有 1 个元素。

关键反证:不是硬件限制。 同一台设备、同一份输入,torch._foreach_norm 对全部 p 都正确:

p torch._foreach_norm(NPU) aclnnForeachNorm(同 NPU)
1.0 3.0 3.0
1.5 2.3207943 3.0(=Σ|x|)
2.0 2.1213205 2.1213205
2.5 2.0490925 2.1213205(=L2)
3.0 2.0206201 2.1213205
nan nan 2.1213205

(x = [0.5, 2.0, 0.0, -0.5];torch.linalg.vector_norm(npu, 1.5) 同样给 2.3207943。)

2)环境信息

  • 昇腾硬件型号:Atlas A3 系列(Ascend910,npu-smi 26.1.1)
  • CANN 版本:9.2.0-beta.2(Ascend-cann-toolkit_9.2.0-beta.2_linux-aarch64)
  • Python 版本:3.12.15
  • 仓版本:cann/ops-nn@118c0c71
  • 交叉验证:Atlas A2 910B3 + 同版本 CANN,结论逐值一致

3)重现步骤

自包含 C++ 复现(aclInit → 构造 → 两段调用 → 读回,不依赖任何测试框架):

#include <cstdio>
#include <cmath>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_foreach_norm.h"

static aclTensor* mk(const std::vector<float>& d, const std::vector<int64_t>& s, void** dev) {
  size_t n = 1; for (auto v : s) n *= (size_t)v;
  size_t bytes = n * sizeof(float);
  if (aclrtMalloc(dev, bytes, ACL_MEM_MALLOC_HUGE_FIRST) != 0) return nullptr;
  if (aclrtMemcpy(*dev, bytes, d.data(), bytes, ACL_MEMCPY_HOST_TO_DEVICE) != 0) return nullptr;
  std::vector<int64_t> st(s.size(), 1);
  for (int64_t i = (int64_t)s.size() - 2; i >= 0; --i) st[i] = s[i+1] * st[i+1];
  return aclCreateTensor(s.data(), s.size(), ACL_FLOAT, st.data(), 0, ACL_FORMAT_ND,
                         s.data(), s.size(), *dev);
}

int main() {
  aclInit(nullptr); aclrtSetDevice(0);
  aclrtStream stream = nullptr; aclrtCreateStream(&stream);

  std::vector<int64_t> xs{16, 32}, os{1};
  std::vector<float> xv(512), ov(1, 0.f);
  for (size_t i = 0; i < xv.size(); ++i) xv[i] = 0.25f + 0.5f * (float)(i % 97) / 97.f;

  void *xd = nullptr, *od = nullptr;
  aclTensor* x = mk(xv, xs, &xd);
  aclTensor* o = mk(ov, os, &od);
  aclTensor* xl[1] = {x}; aclTensor* ol[1] = {o};
  aclTensorList* xL = aclCreateTensorList(xl, 1);
  aclTensorList* oL = aclCreateTensorList(ol, 1);

  const double ps[] = {1.0, 1.5, 2.0, 3.0, 0.5, INFINITY, -INFINITY, NAN};
  for (double p : ps) {
    // 注意:double 变量必须配 ACL_DOUBLE;配 ACL_FLOAT 会因只读 4 字节而全变成 0
    aclScalar* sc = aclCreateScalar(&p, ACL_DOUBLE);
    uint64_t ws = 0; aclOpExecutor* ex = nullptr;
    auto r1 = aclnnForeachNormGetWorkspaceSize(xL, sc, oL, &ws, &ex);
    printf("p=%-6g ret_gws=%-3d ", p, (int)r1);
    if (r1 == 0) {
      void* w = nullptr;
      if (ws > 0) aclrtMalloc(&w, ws, ACL_MEM_MALLOC_HUGE_FIRST);
      auto r2 = aclnnForeachNorm(w, ws, ex, stream);
      aclrtSynchronizeStream(stream);
      float got = 0.f;
      aclrtMemcpy(&got, sizeof(got), od, sizeof(got), ACL_MEMCPY_DEVICE_TO_HOST);
      printf("ret_exec=%-3d out[0]=%.6g", (int)r2, got);
      if (ws > 0) aclrtFree(w);
    }
    printf("\n");
    aclDestroyScalar(sc);
  }
  aclDestroyTensorList(xL); aclDestroyTensorList(oL);
  aclrtFree(xd); aclrtFree(od);
  aclrtDestroyStream(stream); aclrtResetDevice(0); aclFinalize();
  return 0;
}

编译:

g++ -std=c++17 probe.cpp -o probe \
  -I$ASCEND_HOME_PATH/include -L$ASCEND_HOME_PATH/aarch64-linux/lib64 \
  -L$ASCEND_HOME_PATH/lib64 -lopapi -lnnopbase -lacl_rt
./probe

实测输出(A3):

p=1      ret_gws=0 ret_exec=0 out[0]=249.809
p=1.5    ret_gws=0 ret_exec=0 out[0]=249.809     <- 与 p=1 完全相同
p=2      ret_gws=0 ret_exec=0 out[0]=11.5266
p=3      ret_gws=0 ret_exec=0 out[0]=11.5266     <- 与 p=2 完全相同
p=0.5    ret_gws=0 ret_exec=0 out[0]=11.5266
p=inf    ret_gws=0 ret_exec=0 out[0]=11.5266
p=-inf   ret_gws=0 ret_exec=0 out[0]=11.5266
p=nan    ret_gws=0 ret_exec=0 out[0]=11.5266

一行 PyTorch 对照(证明非硬件限制):

import torch, torch_npu
x = torch.tensor([0.5, 2.0, 0.0, -0.5], dtype=torch.float32)
print('cpu p=1.5:', torch._foreach_norm([x], 1.5)[0].item())          # 2.3207943
print('npu p=1.5:', torch._foreach_norm([x.npu()], 1.5)[0].item())    # 2.3207943 同样正确

4)预期结果

以下两种修复任一即可:

  1. 按资料公式实现:p ∉ {1,2} 时按 (Σ|x|^p)^(1/p) 计算,
    并补齐 ±inf → max/min|x|(950 资料已明写该语义);
  2. 或显式拒绝:p ∉ {1,2} 时第一段返回非 0(161002 / 561002),
    并在资料 scalar 参数说明里写明「仅支持 1 与 2」。

现状是第三种:既不按公式算、也不拒绝,静默返回另一个阶数的值 ——
调用方传 p=3 拿到 L2 范数、传 p=1.5 拿到 L1 范数,无从察觉。

5)仓内定位参考

文件:行 内容
foreach/foreach_norm/op_kernel/foreach_norm.cpp:24-35 注释:modelCode 2: p=1 ... 3: p=2 ... (now we only consider p=1 || p=2)
foreach/foreach_norm/op_kernel/foreach_norm.cpp:55-57 if (static_cast<int>(scalarVal) == 1) { modelCode = ONE...; },之后仅 if/else 两条分支
foreach/foreach_norm/op_host/foreach_norm_def.cpp:30-31 scalar 仅声明 .Scalar(),无任何取值校验
foreach/foreach_norm/op_host/foreach_norm_infershape.cpp 无 p 相关约束

static_cast<int>(1.5) == 1 → 落 p=1;其余(含 nan / ±inf / 0.5 / 负数)走 else → 落 p=2。
这与实测「p=1.5 得 L1、p≥2 与 p=0.5/±inf/nan 得 L2」完全吻合。

6)影响面

任何用 aclnnForeachNorm(x, p) 做 L1/L2 以外范数(L3、L0.5、L∞、L−∞)的调用方
都会拿到错误结果,且无任何报错。A2、A3 两个产品均复现。

7)备注

  • 本条与 #7710(Documentation:公式未区分张量列表与单张量内元素)不同,
    #7710 讲表述歧义,本条讲 p 取值的语义漂移。
  • 已排查:cann/ops-nn 1500 条 issue 中无同题。
likedislike
liuhanwen8
liuhanwen8
19 days ago Comments:

补充证据(2026-11-03,A3 910_9362 / CANN 9.2.0-beta.2)

一、p 语义的完整边界(26 个取值全谱扫描)

固定输入 x = [0.6606, 0.5879, 0.5558, 0.7391, 0.5660, 0.6953],fp32
(L1 = Σ|x| = 3.804700,L2 = √Σx² = 1.562370):

p 取值 设备输出 落到的分支
1 / 1.0000001 / 1.001 / 1.1 / 1.5 / 1.9 / 1.9999999 3.80469799 L1
0.5 / 0.9 / 0.999 / 0 1.56236744 L2
2 / 2.0000001 / 2.5 / 3 / 4 / 10 1.56236744 L2
-1 / -2 / -0.5 1.56236744 L2
2147483647 / 2147483648 / 4294967296 / 1e10 1.56236744 L2
inf / -inf / nan 1.56236744 L2

二、三条比原报告更强的论断

1. 区间语义是 trunc,不是 rint、不是近似匹配。
p = 1.9999999 仍走 L1 —— 这不是「p 接近 1 时容差匹配」,而是
static_cast<int>(1.9999999) == 1 的直接结果。
整个开区间 p ∈ [1.0, 2.0) 全部塌成 p=1。

2. 除 trunc(p)==1 之外全部落默认分支。

// foreach_norm.cpp:51
uint8_t modelCode = TWO_SCALAR_NORM_MODEL_CODE;          // 默认 = L2
// foreach_norm.cpp:56
if (static_cast<int>(scalarVal) == 1) modelCode = ONE;   // 唯一分支

不是「p=3 时算错」,而是「只有 p∈[1,2) 走 L1、其余一切都走 L2」。

3. p ≥ 2^31 时 static_cast<int>(float) 是 C++ UB,设备静默返回合法值。

p = 2147483648 / 4294967296 / 1e10 / inf / nan 实测:

  • 无错误码(两段均返回 0)
  • 无异常/日志
  • 返回 1.56236744(= L2),一个看起来完全合理的值

这一点比「p=3 返回 L2」严重:后者用户对比两次不同 p 就能发现异常;
UB 区间连「该期待什么」都无法确定,日志干净、返回码 0,线上极难察觉。

三、死代码证据

// foreach_norm.cpp:30-35 —— 定义了 6 个常量
constexpr uint8_t ZERO_SCALAR_NORM_MODEL_CODE         = 0;  // 注释标 "not used now"
constexpr uint8_t ONE_SCALAR_NORM_MODEL_CODE          = 1;
constexpr uint8_t TWO_SCALAR_NORM_MODEL_CODE          = 2;
constexpr uint8_t POSITIVE_INF_SCALAR_NORM_MODEL_CODE = 3;  // 注释标 "not used now"
constexpr uint8_t NEGATIVE_INF_SCALAR_NORM_MODEL_CODE = 4;  // 注释标 "not used now"
constexpr uint8_t DEFAULT_SCALAR_NORM_MODEL_CODE      = 5;  // 注释标 "not used now"

3/4/5 三个常量在全文件中没有任何赋值点 —— 是死代码。
若资料声明支持 p=+inf / p=-inf,则属「文档声明 vs 实现」不符。

四、非缺陷侧的实测排除(供维护者参考,避免重复投入)

以下三项用真机实测排除,均不是缺陷:

检查项 方法 结果
8 元素块尾块(elementsPerBlock=8) 1/2/7/8/9/15/16/17/23/24/25/63/64/65/127/128/129/255/256/257/511/512/513/1023/1024/1025/4095/4096/4097 共 29 个长度 29/29 PASS,最大相对误差 3.8e-8(fp32 ULP = 1.19e-7)
TensorList 长度上限 n = 1/8/32/63/64/65/96/128/200/256/257 1–256 全 PASS,257 正确拒 161002
非连续输入(transposed / 混合连续非连续) ND vs transposed 逐值比对 全 PASS

其中 list 长度一项值得单独说明:foreach_reduce_tiling_def.h:36-39 的
tensorStartList/tensorEndList/tensorStartOffsetList/tensorEndOffsetList 只有 64 槽,
而长度上限是 256(foreach_reduce_tiling_func.cpp:276),
代码里没有 coreIndex < MAX_CORE_CONT 的钳位。
当前 A3 上 needCoreNum ≤ 64,所以 256 长度恰好安全。
但这是依赖隐含前提而非显式保证:若某代设备 AIV 核数 > 64 或 tiling 逻辑调整,
AssignDataToEachCore 的 coreIndex++(:190)可能越界写 tiling 结构体相邻字段。
目前无实证,仅作风险提示,不建议单独提 issue。

五、复现方式

python3 probe_norm_p_spectrum.py      # p 全谱 26 值扫描
python3 probe_fs_block.py             # 8 元素块尾块 29 点
python3 probe_listlen2.py             # list 长度 1→256
python3 probe_nc_py.py                # 非连续 ND vs transposed
python3 probe_ex_bitscale.py          # EX:连跑 8 次 / 插 shape 扰乱 / 换种子

脚本与原始输出已随本轮归档提交。

likedislike
yuning_chenyuning_chenCollaborators
18 days ago Assign tramp-ll as responsible person
yuning_chen
yuning_chenCollaborators
18 days ago Comments:

初步分析

感谢反馈,我们已开始核对这个问题。

现象理解:aclnnForeachNorm 在 p 不是 1 或 2 时不报错,而是静默返回其他阶数的结果(p=3 返 L2、p=1.5 返 L1),两段接口均返回 0。

当前判断:初步判断是入参 p 缺少取值范围校验、实现按分支回落到已支持阶数,待复现确认具体回落路径,暂不能认定根因。

涉及范围:foreach/foreach_norm 的 op_host 校验与 kernel 实现,以及 aclnnForeachNorm 资料中对 p 支持范围的声明。

下一步:我们会复现 p=1.5/3 等取值,确认应当是补校验返回错误码还是补齐实现,并同步修正资料声明。

likedislike
yuning_chen
yuning_chenCollaborators
18 days ago Comments:

您好,该问题已收到,当前问题 @tramp-ll 正在处理中

likedislike
yuning_chenyuning_chenCollaborators
11 days ago Assign east_yang as responsible person, remove original responsible person: tramp-ll
east_yangeast_yangCollaborators
11 days ago Assign tramp-ll as responsible person
east_yangeast_yangCollaborators
11 days ago Removed responsible person east_yang
tramp-ll
tramp-llCollaborators
10 days ago Comments:

p当前再arch22上只支持1 和 2,其他数值无法保证精度正确,已添加文档说明

likedislike
CANN-robotCANN-robotCollaborators
8 days ago Close issue
CANN-robotCANN-robotCollaborators
8 days ago changed custom state from 进行中 to 已完成
CANN-robotCANN-robotCollaborators
8 days ago Added label: resolved