首页
产品
解决方案
开发者
合作伙伴
高校
昇腾AI市场
产业资讯
支持与服务
文档HOT
下载
中文
注册
文档首页
我要评分
文档获取效率
文档正确性
内容完整性
文档易理解
提交
在线提单
论坛求助
昇腾小AI

aclnnWeightQuantBatchMatmulV2

支持的产品型号

  • Atlas A2训练系列产品/Atlas 800I A2推理产品
  • Atlas 推理系列产品

接口原型

每个算子分为两段式接口，必须先调用“aclnnWeightQuantBatchMatmulV2GetWorkspaceSize”接口获取计算所需workspace大小以及包含了算子计算流程的执行器，再调用“aclnnWeightQuantBatchMatmulV2”接口执行计算。

  • aclnnStatus aclnnWeightQuantBatchMatmulV2GetWorkspaceSize(const aclTensor *x, const aclTensor *weight, const aclTensor *antiquantScale, const aclTensor *antiquantOffsetOptional, const aclTensor *quantScaleOptional, const aclTensor *quantOffsetOptional, const aclTensor *biasOptional, int antiquantGroupSize, const aclTensor *y, uint64_t *workspaceSize, aclOpExecutor **executor)
  • aclnnStatus aclnnWeightQuantBatchMatmulV2(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

  • 算子功能：完成一个输入为伪量化场景的矩阵乘计算，并可以实现对于输出的量化计算。
  • 计算公式：y=x@ANTIQUANT(weight)+biasy = x @ ANTIQUANT(weight) + bias 公式中的weightweight为伪量化场景的输入，其反量化公式ANTIQUANT(weight)ANTIQUANT(weight)为ANTIQUANT(weight)=(weight+antiquantOffset)∗antiquantScaleANTIQUANT(weight) = (weight + antiquantOffset) * antiquantScale 当客户配置quantScaleOptional输入时, 会对输出进行量化处理, 其量化公式为y=QUANT(x@ANTIQUANT(weight)+bias)=(x@ANTIQUANT(weight)+bias)∗quantScale+quantOffset\begin{aligned} y &= QUANT(x @ ANTIQUANT(weight) + bias) \\ &= (x @ ANTIQUANT(weight) + bias) * quantScale + quantOffset \\ \end{aligned} 当客户配置quantScaleOptional输入为nullptr, 则直接输出:y=x@ANTIQUANT(weight)+biasy = x @ ANTIQUANT(weight) + bias

aclnnWeightQuantBatchMatmulV2GetWorkspaceSize

  • 参数说明

    • x(const aclTensor*, 计算输入)：公式中的输入x，数据类型支持FLOAT16、BFLOAT16，数据格式支持ND。非连续的Tensor仅支持transpose场景。维度支持二维，shape支持(m, k)，其中Reduce维度k需要与weight的Reduce维度k大小相等；Atlas 推理系列产品中数据类型仅支持FLOAT16，当weight输入Format为FRACTAL_NZ时维度仅支持2维。其余限制与其他平台一致。

    • weight(const aclTensor*, 计算输入)：公式中的输入weight，数据类型支持INT8、INT4、INT32(仅在INT4Pack场景支持，需要配合aclnnConvertWeightToINT4Pack接口完成从INT32到INT4Pack的转换, 参考样例),其中若数据类型为INT4，则weight的内轴应为偶数。Atlas A2训练系列产品/Atlas 800I A2推理产品中数据格式支持ND、FRACTAL_NZ, 非连续的Tensor仅支持transpose场景。维度支持二维，shape支持(k, n)，其中Reduce维度k需要与x的Reduce维度k大小相等；Atlas 推理系列产品中数据类型仅支持INT8, 数据格式支持FRACTAL_NZ，维度仅支持2维，且输入shape需要为（n, k），配合aclnnCalculateMatmulWeightSizeV2以及aclnnTransMatmulWeight完成输入Format从ND到FRACTAL_NZ的转换，参考样例。其余限制与其他平台一致。

    • antiquantScale(const aclTensor*, 计算输入)：实现输入反量化计算的反量化scale参数，反量化公式中的输入antiquantScale，数据类型支持FLOAT16、BFLOAT16，且要求和输入x的数据类型保持一致。Atlas A2训练系列产品/Atlas 800I A2推理产品中，数据类型还支持UINT64（使用该类型时x仅支持FLOAT16，weight仅支持转置，模式仅支持per_channel, quantScaleOptional和quantOffsetOptional必须为空），需要首先配合aclnnCast接口完成FLOAT16到FLOAT32的转换，参考样例，再配合aclnnTransQuantParamV2接口完成FLOAT32到UINT64的转换，参考样例。数据格式支持ND。非连续的Tensor仅支持transpose场景。对于不同伪量化算法模式，antiquantScale支持的shape如下:

      • per_tensor模式：(1,)
      • per_channel模式：Atlas A2训练系列产品/Atlas 800I A2推理产品中输入shape为(1, n)或(n,)。Atlas 推理系列产品中输入shape需要为(n, 1)或(n,)。
      • per_group模式：Atlas A2训练系列产品/Atlas 800I A2推理产品中输入shape为(ceil(k, group_size), n)。Atlas 推理系列产品中输入shape需要为(n, ceil(k, group_size))。

    • antiquantOffsetOptional(const aclTensor*, 计算输入)：实现输入反量化计算的反量化offset参数，反量化公式中的输入antiquantOffset，数据类型支持FLOAT16、BFLOAT16，且要求和输入x的数据类型保持一致。Atlas A2训练系列产品/Atlas 800I A2推理产品中，数据类型还支持INT32，且数据范围限制为[-128, 127]（使用该类型时，antiquantScale仅支持UINT64）。可选输入, 当不需要时为空指针；存在时shape要求与antiquantScale一致。数据格式支持ND。非连续的Tensor仅支持transpose场景。

    • quantScaleOptional(const aclTensor*, 计算输入)：实现输出量化计算的量化参数（Atlas 推理系列产品中为预留参数，暂未使用），由量化公式中的quantScale和quantOffset的数据通过aclnnTransQuantParam接口转化得到。数据类型支持UINT64，数据格式支持ND。不支持非连续的Tensor。可选输入，当不需要时为空指针（Atlas 推理系列产品中为预留参数，暂未使用）；对于不同的伪量化算法模式，支持的shape如下:

      • per_tensor模式：(1,)
      • per_channel模式：(1, n)或(n,)

    • quantOffsetOptional(const aclTensor*, 计算输入)：实现输出量化计算的量化offset参数，量化公式中的输入quantOffset，数据类型支持FLOAT，数据格式支持ND。可选输入, 当不需要时为空指针（Atlas 推理系列产品中为预留参数，暂未使用）；存在时shape要求与quantScaleOptional一致。不支持非连续的Tensor。

    • biasOptional(aclTensor*, 计算输入)：偏置输入，公式中的输入bias。当输入x的数据类型为BFLOAT16时，数据类型要求为FLOAT；当输入x的数据类型为FLOAT16时，数据类型要求为FLOAT16。可选输入, 当不需要时为空指针；存在输入时支持1维或2维，shape支持(n,)或(1, n)。支持ND。不支持非连续的Tensor。

    • antiquantGroupSize(int, 计算输入)：表示伪量化per_group算法模式下，对输入weight进行反量化计算的groupSize输入，描述一组反量化参数对应的待反量化数据量在Reduce方向的大小。当伪量化算法模式不为per_group时传入0；当伪量化算法模式为per_group时传入值的范围为[32,k-1]且值要求是32的倍数。

    • y(aclTensor*, 计算输出)：计算输出，公式中的y。当quantScaleOptional存在时，数据类型为INT8；当quantScaleOptional不存在时，数据类型支持FLOAT16、BFLOAT16，且与输入x的数据类型一致。维度支持二维，shape支持(m, n)。数据格式支持ND。不支持非连续的Tensor。

    • workspaceSize(uint64_t*, 出参)：返回需要在Device侧申请的workspace大小。

    • executor(aclOpExecutor**, 出参)：返回op执行器，包含了算子计算流程。

  • 返回值：

    aclnnStatus：返回状态码，具体参见aclnn返回码。

    说明 第一段接口完成入参校验，若出现以下错误码，则对应原因为：

    • 返回161001 (ACLNN_ERR_PARAM_NULLPTR)：如果传入参数是必选输入，输出或者必选属性，且是空指针，则返回161001。
    • 返回161002 (ACLNN_ERR_PARAM_INVALID)：原因有：
      • 传入x、weight、antiquantScale、antiquantOffsetOptional、quantScaleOptional、quantOffsetOptional、biasOptional、y的shape维度不符合要求。
      • 传入x、weight、antiquantScale、antiquantOffsetOptional、quantScaleOptional、quantOffsetOptional、biasOptional、y的数据类型不在支持的范围之内。
      • x、weight的reduce维度(k)不相等。
      • antiquantOffsetOptional存在输入时，shape与antiquantScale不相同。
      • quantOffsetOptional存在输入时，shape与quantScale不相同。
      • biasOptional的shape不符合要求。
      • antiquantGroupSize值不符合要求。
      • quantOffsetOptional存在时，quantScaleOptional是空指针。
      • 输入的k、n值不在[1, 65535]范围内；
      • x矩阵为非转置时，m不在[1, 2^31-1]范围内；转置时，m不在[1, 65535]范围内
      • 不支持空tensor场景。
      • 输入tensor的数据格式不在支持范围内。
      • 传入x、weight、antiquantScale、antiquantOffsetOptional、quantScaleOptional、quantOffsetOptional、biasOptional、y的连续性不符合要求。
    • 返回361001(ACLNN_ERR_RUNTIME_ERROR): SocVersion不支持。

aclnnWeightQuantBatchMatmulV2

  • 参数说明

    • workspace(void*, 入参)：在Device侧申请的workspace内存地址。
    • workspaceSize(uint64_t, 入参)：在Device侧申请的workspace大小，由第一段接口aclnnWeightQuantBatchMatmulV2GetWorkspaceSize获取。
    • executor(aclOpExecutor*, 入参)：op执行器，包含了算子计算流程。
    • stream(aclrtStream, 入参)：指定执行任务的AscendCL Stream流。

  • 返回值：

    aclnnStatus：返回状态码，具体参见aclnn返回码。

约束与限制

per_channel模式: 为提高性能，推荐使用transpose后的weight输入。m范围为[65,96]时，推荐使用数据类型为UINT64的antiquantScale。

调用示例

示例代码如下，仅供参考，具体编译和执行过程请参考编译与运行样例。

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_cast.h"
#include "aclnnop/aclnn_weight_quant_batch_matmul_v2.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) {
  // 固定写法，AscendCL初始化
  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初始化，参考AscendCL对外接口列表
  // 根据自己的实际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> xShape = {16, 32};
  std::vector<int64_t> weightShape = {32, 16};
  std::vector<int64_t> yShape = {16, 16};
  void* xDeviceAddr = nullptr;
  void* weightDeviceAddr = nullptr;
  void* yDeviceAddr = nullptr;
  aclTensor* x = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* y = nullptr;
  std::vector<float> xHostData(512, 1);
  std::vector<int8_t> weightHostData(512, 1);
  std::vector<float> yHostData(256, 0);

  std::vector<int64_t> antiquantScaleShape = {16};
  void* antiquantScaleDeviceAddr = nullptr;
  aclTensor* antiquantScale = nullptr;
  std::vector<float> antiquantScaleHostData(16, 1);

  // 创建x aclTensor
  ret = CreateAclTensor(xHostData, xShape, &xDeviceAddr, aclDataType::ACL_FLOAT, &x);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建other aclTensor
  ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_INT8, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建y aclTensor
  ret = CreateAclTensor(yHostData, yShape, &yDeviceAddr, aclDataType::ACL_FLOAT, &y);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建antiquantScale aclTensor
  ret = CreateAclTensor(antiquantScaleHostData, antiquantScaleShape, &antiquantScaleDeviceAddr, aclDataType::ACL_FLOAT, &antiquantScale);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 创建xFp16 aclTensor
  void* xFp16DeviceAddr = nullptr;
  aclTensor* xFp16 = nullptr;
  ret = CreateAclTensor(xHostData, xShape, &xFp16DeviceAddr, aclDataType::ACL_FLOAT16, &xFp16);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建antiquantScale aclTensor
  void* antiquantScaleFp16DeviceAddr = nullptr;
  aclTensor* antiquantScaleFp16 = nullptr;
  ret = CreateAclTensor(antiquantScaleHostData, antiquantScaleShape, &antiquantScaleFp16DeviceAddr, aclDataType::ACL_FLOAT16, &antiquantScaleFp16);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建yFp16 aclTensor
  void* yFp16DeviceAddr = nullptr;
  aclTensor* yFp16 = nullptr;
  ret = CreateAclTensor(yHostData, yShape, &yFp16DeviceAddr, aclDataType::ACL_FLOAT16, &yFp16);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. 调用CANN算子库API，需要修改为具体的Api名称
  int8_t cubeMathType = 1;
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  void* workspaceAddr = nullptr;

  // 调用cast生成FP16的输入
  ret = aclnnCastGetWorkspaceSize(x, aclDataType::ACL_FLOAT16, xFp16, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCastGetWorkspaceSize0 failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存

  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);
  }
  ret = aclnnCast(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCast0 failed. ERROR: %d\n", ret); return ret);

  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

  ret = aclnnCastGetWorkspaceSize(antiquantScale, aclDataType::ACL_FLOAT16, antiquantScaleFp16, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCastGetWorkspaceSize1 failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存

  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);
  }
  ret = aclnnCast(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCast1 failed. ERROR: %d\n", ret); return ret);

  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

  // 调用aclnnWeightQuantBatchMatmulV2第一段接口
  ret = aclnnWeightQuantBatchMatmulV2GetWorkspaceSize(xFp16, weight, antiquantScaleFp16, nullptr, nullptr, nullptr, nullptr, 0, yFp16, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnWeightQuantBatchMatmulV2GetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存

  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);
  }
  // 调用aclnnWeightQuantBatchMatmulV2第二段接口
  ret = aclnnWeightQuantBatchMatmulV2(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnWeightQuantBatchMatmulV2 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);

 // 将输出转为FP32
  ret = aclnnCastGetWorkspaceSize(yFp16, aclDataType::ACL_FLOAT, y, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCastGetWorkspaceSize2 failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存

  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);
  }
  ret = aclnnCast(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnCast2 failed. ERROR: %d\n", ret); return ret);

  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(yShape);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), yDeviceAddr,
                    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("result[%ld] is: %f\n", i, resultData[i]);
  }

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(x);
  aclDestroyTensor(weight);
  aclDestroyTensor(antiquantScale);
  aclDestroyTensor(y);
  aclDestroyTensor(xFp16);
  aclDestroyTensor(antiquantScaleFp16);
  aclDestroyTensor(yFp16);

  // 7. 释放device资源
  aclrtFree(xDeviceAddr);
  aclrtFree(weightDeviceAddr);
  aclrtFree(antiquantScaleDeviceAddr);
  aclrtFree(yDeviceAddr);
  aclrtFree(xFp16DeviceAddr);
  aclrtFree(antiquantScaleFp16DeviceAddr);
  aclrtFree(yFp16DeviceAddr);

  if (workspaceSize > 0) {
    aclrtFree(workspaceAddr);
  }
  aclrtDestroyStream(stream);
  aclrtResetDevice(deviceId);
  aclFinalize();

  return 0;
}
搜索结果
找到“0”个结果

当前产品无相关内容

未找到相关内容，请尝试其他搜索词