企业官网建设流程全解析

aclnnFlashAttentionUnpaddingScoreGradV3

【免费下载链接】ops-transformer本项目是CANN提供的transformer类大模型算子库，实现网络在NPU上加速计算。项目地址: https://gitcode.com/cann/ops-transformer

产品支持情况

功能说明

• 接口功能：训练场景下计算注意力的反向输出，即aclnnFlashAttentionVarLenScoreV3的反向计算。该接口相较于aclnnFlashAttentionUnpaddingScoreGradV2接口，新增queryRope、keyRope、dqRope和dkRope参数。

• 计算公式：

  已知注意力的正向计算公式：

  $$ Y=Dropout(Softmax(Mask(\frac{QK^T}{\sqrt{d}}+pse),atten_mask),keep_prob)V $$

  其中:

  $$ Q=[query, queryRope], K=[key, keyRope] $$

  为方便表达，以变量$S$和$P$表示计算公式：

  $$ S=Mask(\frac{QK^T}{\sqrt{d}}+pse),atten_mask $$

  $$ P=Dropout(Softmax(S),keep_prob) $$

  $$ Y=PV $$

  则注意力的反向计算公式为：

  $$ dV=P^TdY $$

  $$ dQ=\frac{((dS)*K)}{\sqrt{d}} $$

  $$ dqRope=\frac{((dS)*kRope)}{\sqrt{d}} $$

  $$ dK=\frac{((dS)^T*Q)}{\sqrt{d}} $$

  $$ dkRope=\frac{((dS)^T*qRope)}{\sqrt{d}} $$

函数原型

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

aclnnStatus aclnnFlashAttentionUnpaddingScoreGradV3GetWorkspaceSize( const aclTensor *query, const aclTensor *queryRope, const aclTensor *keyIn, const aclTensor *keyInRope, const aclTensor *value, const aclTensor *dy, const aclTensor *pseShiftOptional, const aclTensor *dropMaskOptional, const aclTensor *paddingMaskOptional, const aclTensor *attenMaskOptional, const aclTensor *softmaxMaxOptional, const aclTensor *softmaxSumOptional, const aclTensor *softmaxInOptional, const aclTensor *attentionInOptional, const aclIntArray *prefixOptional, const aclIntArray *actualSeqQLenOptional, const aclIntArray *actualSeqKvLenOptional, const aclIntArray *qStartIdxOptional, const aclIntArray *kvStartIdxOptional, double scaleValue, double keepProb, int64_t preTokens, int64_t nextTokens, int64_t headNum, char *inputLayout, int64_t innerPrecise, int64_t sparseMode, int64_t pseType, const aclTensor *dqOut, const aclTensor *dqRopeOut, const aclTensor *dkOut, const aclTensor *dkRopeOut, const aclTensor *dvOut, const aclTensor *dpseOut, uint64_t *workspaceSize, aclOpExecutor **executor)

aclnnStatus aclnnFlashAttentionUnpaddingScoreGradV3( void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

aclnnFlashAttentionUnpaddingScoreGradV3GetWorkspaceSize

• 参数说明

  参数名	输入/输出	描述	使用说明	数据类型	数据格式	维度(shape)	非连续Tensor
  query	输入	公式中的Q。	数据类型与keyIn/value一致。	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  queryRope	可选输入	Q的rope部分（旋转位置编码）。	数据类型与query一致。	BFLOAT16	ND	[TND]	√
  keyIn	输入	公式中的K。	数据类型与query/value一致。	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  keyInRope	可选输入	K的rope部分。	数据类型与keyIn一致。	BFLOAT16	ND	[TND]	√
  value	输入	公式中的V。	数据类型与query/keyIn一致。	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  dy	输入	公式中的dY。	-	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  pseShiftOptional	可选输入	公式中的pse，位置编码。	必须为nullptr。	-	-	-	-
  dropMaskOptional	可选输入	Dropout掩码。	必须为nullptr。	-	-	-	-
  paddingMaskOptional	可选输入	预留参数，暂未使用。	调用时需传空。	-	-	-	-
  qStartIdxOptional	可选输入	外切场景，当前分块Query在全局序列中的起始索引。	-	INT64	ND	0、1	-
  kvStartIdxOptional	可选输入	外切场景，当前分块Key/Value在全局序列中的起始索引。	-	INT64	ND	0、1	-
  attenMaskOptional	可选输入	公式中的atten_mask。	取值为1代表该位不参与计算，为0代表该位参与计算。	BOOL、UINT8	ND	[B,N,Sq,Skv]、[B,1,Sq,Skv]、[1,1,Sq,Skv]、[Sq,Skv]	√
  softmaxMaxOptional	可选输入	正向softmax中间输出。	-	FLOAT	ND	[N,T,8]	√
  softmaxSumOptional	可选输入	正向softmax中间输出。	-	FLOAT	ND	[N,T,8]	√
  softmaxInOptional	可选输入	正向softmax的中间输出。	预留参数，暂未使用。	-	-	-	-
  attentionInOptional	可选输入	正向注意力输出。	与query数据类型、shape一致。	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  prefixOptional	可选输入	prefix稀疏场景每个Batch的N值。	可传nullptr。	INT64	ND	0、1	-
  actualSeqQLenOptional	可选输入	实际Query序列长度。	-	INT64	ND	1	-
  actualSeqKvLenOptional	可选输入	实际Key/Value序列长度。	-	INT64	ND	1	-
  scaleValue	可选输入	scale缩放系数。	-	DOUBLE	-	-	-
  keepProb	可选输入	dropMaskOptional中1的比例。	-	DOUBLE	-	-	-
  preTokens	可选输入	稀疏计算时滑窗左边界。	-	INT64	-	-	-
  nextTokens	可选输入	稀疏计算时滑窗右边界。	-	INT64	-	-	-
  headNum	输入	单卡head数量，即Query的N轴长度。	-	INT64	-	-	-
  inputLayout	输入	输入Q/K/V数据排布。	支持TND。	String	-	-	-
  innerPrecise	可选输入	内部计算精度控制。	保留参数，暂未使用。	INT64	-	-	-
  sparseMode	可选输入	稀疏模式。	支持配置0~8。不支持5、6。	INT64	-	-	-
  pseType	可选输入	数据类型支持INT64。	仅支持配置值为1。	INT64	-	-	-
  dqOut	输出	公式中的dQ，Query梯度。	-	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  dqRopeOut	输出	Q的rope梯度。	-	BFLOAT16	ND	[TND]	√
  dkOut	输出	公式中的dK，Key梯度。	-	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  dkRopeOut	输出	K的rope梯度。	-	BFLOAT16	ND	[TND]	√
  dvOut	输出	公式中的dV，Value梯度。	-	FLOAT16、BFLOAT16、FLOAT32	ND	[TND]	√
  dpseOut	输出	d(pse)梯度。	预留参数，暂未使用。	-	-	-	-
  workspaceSize	输出	返回需要Device侧申请的workspace大小。	-	-	-	-	-
  executor	输出	返回op执行器，包含算子计算流程。	-	-	-	-	-

• 返回值

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

  第一段接口完成入参校验，出现以下场景时报错：

  返回值	错误码	描述
  ACLNN_ERR_PARAM_NULLPTR	161001	传入参数是必选输入，输出或者必选属性，且是空指针。
  ACLNN_ERR_PARAM_INVALID	161002	query、queryRope、keyIn、keyInRope、value、dy、pseShiftOptional、dropMaskOptional、paddingMaskOptional、attenMaskOptional、softmaxMaxOptional、softmaxSumOptional、softmaxInOptional、attentionInOptional、dqOut、dkOut、dvOut 的数据类型不在支持的范围内。
  		query、queryRope、keyIn、keyInRope、value、dy、pseShiftOptional、dropMaskOptional、paddingMaskOptional、attenMaskOptional、softmaxMaxOptional、softmaxSumOptional、softmaxInOptional、attentionInOptional、dqOut、dkOut、dvOut 的数据格式不在支持的范围内。

aclnnFlashAttentionUnpaddingScoreGradV3

• 参数说明

  参数名	输入/输出	描述
  workspace	输入	在Device侧申请的workspace内存地址。
  workspaceSize	输入	在Device侧申请的workspace大小，由第一段接口aclnnFlashAttentionUnpaddingScoreGradV3GetWorkspaceSize获取。
  executor	输入	op执行器，包含了算子计算流程。
  stream	输入	指定执行任务的Stream。

• 返回值

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

约束说明

• 确定性计算：
  • aclnnFlashAttentionUnpaddingScoreGradV3默认非确定性实现，支持通过aclrtCtxSetSysParamOpt开启确定性。
• 该接口与PyTorch配合使用时，需要保证CANN相关包与PyTorch相关包的版本匹配
• 输入query、queryRope、key、keyRope、value、dy的B：batchsize必须相等。
• 输入query、queryRope、key、keyRope、value、dy的inputLayout必须是TND。
• 在query/key/value的d大小相同的情况下，query/dy的shape必须一致。
• query/key的d大小必须相同，d必须是8的整数倍。
• queryRope/keyRope的d大小必须相同，d必须是8的整数倍，且需小于等于query/key的d。
• 支持输入query/dy的N和key/value的N不相等，但必须成比例关系，即Nq/Nkv必须是非0整数，Nq取值范围1~256。
• 关于数据shape的约束，以inputLayout的TND为例，其中：
  • T：取值范围为1~1M。
  • N：取值范围为1~256。
  • D：取值范围为1~768。
  • KeepProb：取值范围为1。
• query、key、value数据排布格式仅支持TND，T是B和S合轴紧密排列的数据（每个batch的SeqLenQ和SeqLenKV），其中B（Batch）表示输入样本批量大小、S（Seq-Length）表示输入样本序列长度、H（Head-Size）表示隐藏层的大小、N（Head-Num）表示多头数、D（Head-Dim）表示隐藏层最小的单元尺寸，且满足D=H/N。
• sparseMode的约束如下:
  • 当所有的attenMaskOptional的shape小于2048且相同的时候，建议使用default模式，来减少内存使用量；
  • 配置为1、2、3时，用户配置的preTokens、nextTokens不会生效；
  • 配置为0、4时，须保证attenMaskOptional与preTokens、nextTokens的范围一致。
  • 用户不特意指定时建议传入0。
  • sparse不同模式的详细说明请参见sparse模式说明。
  • 配置为7时，不支持可选输入pseShiftOptional。
  • 配置为8时，当每个sequence的q、kv等长时支持可选输入pseShiftOptional，针对全局做pse生成。支持q方向进行外切，需要外切前每个sequence的q、kv等长，外切后传入的actualSeqQLenOptional[0] - actualSeqKvLenOptional[0] + qStartIdxOptional - kvStartIdxOptional == 0（本功能属实验性功能）。
• 部分场景下，如果计算量过大可能会导致算子执行超时（aicore error类型报错，errorStr为：timeout or trap error），此时建议做轴切分处理，注：这里的计算量会受B、S、N、D等参数的影响，值越大计算量越大。
• actualSeqQLenOptional输入支持某个Batch上的S长度为0，此时不支持可选输入pseShiftOptional。actualSeqQLenOptional的长度取值范围为1~2K。当存在prefixOptional输入的时候，其长度最大支持1K。
• 关于softmaxMax与softmaxSum参数的约束：输入格式固定为[T, N, 8]，注：T=B*S
• headNum的取值必须和传入的Query中的N值保持一致。
• pseType只能为1。
• pseShiftOptional必须为空。
• dropMaskOptional必须为空。
• attenMaskOptional不能为空。

调用示例

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

#include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_flash_attention_score_grad.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; } void PrintOutResult(std::vector<int64_t> &shape, void** deviceAddr) { auto size = GetShapeSize(shape); std::vector<float> resultData(size, 0); auto ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), *deviceAddr, 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); for (int64_t i = 0; i < size; i++) { LOG_PRINT("mean result[%ld] is: %f\n", i, resultData[i]); } } int Init(int32_t deviceId, aclrtStream* stream) { // 固定写法，资源初始化 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初始化，参考acl API手册 // 根据自己的实际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> qShape = {256, 1, 128}; std::vector<int64_t> qRopeShape = {256, 1, 64}; std::vector<int64_t> kShape = {256, 1, 128}; std::vector<int64_t> kRopeShape = {256, 1, 64}; std::vector<int64_t> vShape = {256, 1, 128}; std::vector<int64_t> dxShape = {256, 1, 128}; std::vector<int64_t> attenmaskShape = {256, 256}; std::vector<int64_t> softmaxMaxShape = {256, 1, 8}; std::vector<int64_t> softmaxSumShape = {256, 1, 8}; std::vector<int64_t> attentionInShape = {256, 1, 128}; std::vector<int64_t> dqShape = {256, 1, 128}; std::vector<int64_t> dqRopeShape = {256, 1, 64}; std::vector<int64_t> dkShape = {256, 1, 128}; std::vector<int64_t> dkRopeShape = {256, 1, 64}; std::vector<int64_t> dvShape = {256, 1, 128}; void* qDeviceAddr = nullptr; void* qRopeDeviceAddr = nullptr; void* kDeviceAddr = nullptr; void* kRopeDeviceAddr = nullptr; void* vDeviceAddr = nullptr; void* dxDeviceAddr = nullptr; void* attenmaskDeviceAddr = nullptr; void* softmaxMaxDeviceAddr = nullptr; void* softmaxSumDeviceAddr = nullptr; void* attentionInDeviceAddr = nullptr; void* dqDeviceAddr = nullptr; void* dqRopeDeviceAddr = nullptr; void* dkDeviceAddr = nullptr; void* dkRopeDeviceAddr = nullptr; void* dvDeviceAddr = nullptr; aclTensor* q = nullptr; aclTensor* qRope = nullptr; aclTensor* k = nullptr; aclTensor* kRope = nullptr; aclTensor* v = nullptr; aclTensor* dx = nullptr; aclTensor* pse = nullptr; aclTensor* dropMask = nullptr; aclTensor* padding = nullptr; aclTensor* attenmask = nullptr; aclTensor* softmaxMax = nullptr; aclTensor* softmaxSum = nullptr; aclTensor* softmaxIn = nullptr; aclTensor* attentionIn = nullptr; aclTensor* dq = nullptr; aclTensor* dqRope = nullptr; aclTensor* dk = nullptr; aclTensor* dkRope = nullptr; aclTensor* dv = nullptr; aclTensor* dpse = nullptr; std::vector<float> qHostData(32768, 1); std::vector<float> qRopeHostData(16384, 1); std::vector<float> kHostData(32768, 1); std::vector<float> kRopeHostData(16384, 1); std::vector<float> vHostData(32768, 1); std::vector<float> dxHostData(32768, 1); std::vector<uint8_t> attenmaskHostData(65536, 0); std::vector<float> softmaxMaxHostData(2048, 3.0); std::vector<float> softmaxSumHostData(2048, 3.0); std::vector<float> attentionInHostData(32768, 1); std::vector<float> dqHostData(32768, 0); std::vector<float> dqRopeHostData(16384, 0); std::vector<float> dkHostData(32768, 0); std::vector<float> dkRopeHostData(16384, 0); std::vector<float> dvHostData(32768, 0); ret = CreateAclTensor(qHostData, qShape, &qDeviceAddr, aclDataType::ACL_BF16, &q); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(qRopeHostData, qRopeShape, &qRopeDeviceAddr, aclDataType::ACL_BF16, &qRope); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(kHostData, kShape, &kDeviceAddr, aclDataType::ACL_BF16, &k); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(kRopeHostData, kRopeShape, &kRopeDeviceAddr, aclDataType::ACL_BF16, &kRope); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(vHostData, vShape, &vDeviceAddr, aclDataType::ACL_BF16, &v); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(dxHostData, dxShape, &dxDeviceAddr, aclDataType::ACL_BF16, &dx); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(attenmaskHostData, attenmaskShape, &attenmaskDeviceAddr, aclDataType::ACL_UINT8, &attenmask); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(softmaxMaxHostData, softmaxMaxShape, &softmaxMaxDeviceAddr, aclDataType::ACL_FLOAT, &softmaxMax); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(softmaxSumHostData, softmaxSumShape, &softmaxSumDeviceAddr, aclDataType::ACL_FLOAT, &softmaxSum); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(attentionInHostData, attentionInShape, &attentionInDeviceAddr, aclDataType::ACL_BF16, &attentionIn); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(dqHostData, dqShape, &dqDeviceAddr, aclDataType::ACL_BF16, &dq); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(dqRopeHostData, dqRopeShape, &dqRopeDeviceAddr, aclDataType::ACL_BF16, &dqRope); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(dkHostData, dkShape, &dkDeviceAddr, aclDataType::ACL_BF16, &dk); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(dkRopeHostData, dkRopeShape, &dkRopeDeviceAddr, aclDataType::ACL_BF16, &dkRope); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(dvHostData, dvShape, &dvDeviceAddr, aclDataType::ACL_BF16, &dv); CHECK_RET(ret == ACL_SUCCESS, return ret); std::vector<int64_t> prefixOp = {0}; aclIntArray* prefix = aclCreateIntArray(prefixOp.data(), 1); std::vector<int64_t> acSeqQLenOp = {256}; std::vector<int64_t> acSeqKvLenOp = {256}; aclIntArray* acSeqQLen = aclCreateIntArray(acSeqQLenOp.data(), acSeqQLenOp.size()); aclIntArray* acSeqKvLen = aclCreateIntArray(acSeqKvLenOp.data(), acSeqKvLenOp.size()); std::vector<int64_t> qStartIdxOp = {0}; std::vector<int64_t> kvStartIdxOp = {0}; aclIntArray *qStartIdx = aclCreateIntArray(qStartIdxOp.data(), 1); aclIntArray *kvStartIdx = aclCreateIntArray(kvStartIdxOp.data(), 1); double scaleValue = 0.088388; double keepProb = 1; int64_t preTokens = 65536; int64_t nextTokens = 65536; int64_t headNum = 1; int64_t innerPrecise = 0; int64_t sparseMode = 0; int64_t pseType = 1; char layOut[5] = {'T', 'N', 'D', 0}; // 3. 调用CANN算子库API，需要修改为具体的Api名称 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnFlashAttentionUnpaddingScoreGradV3第一段接口 ret = aclnnFlashAttentionUnpaddingScoreGradV3GetWorkspaceSize(q, qRope, k, kRope, v, dx, pse, dropMask, padding, attenmask, softmaxMax, softmaxSum, softmaxIn, attentionIn, prefix, acSeqQLen, acSeqKvLen, qStartIdx, kvStartIdx, scaleValue, keepProb, preTokens, nextTokens, headNum, layOut, innerPrecise, sparseMode, pseType, dq, dqRope, dk, dkRope, dv, dpse, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnFlashAttentionUnpaddingScoreGradV3GetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; 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); } // 调用aclnnFlashAttentionUnpaddingScoreGradV3第二段接口 ret = aclnnFlashAttentionUnpaddingScoreGradV3(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnFlashAttentionUnpaddingScoreGradV3 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); // 5. 获取输出的值，将device侧内存上的结果拷贝至host侧，需要根据具体API的接口定义修改 PrintOutResult(dqShape, &dqDeviceAddr); PrintOutResult(dqRopeShape, &dqRopeDeviceAddr); PrintOutResult(dkShape, &dkDeviceAddr); PrintOutResult(dkRopeShape, &dkRopeDeviceAddr); PrintOutResult(dvShape, &dvDeviceAddr); // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(q); aclDestroyTensor(qRope); aclDestroyTensor(k); aclDestroyTensor(kRope); aclDestroyTensor(v); aclDestroyTensor(dx); aclDestroyTensor(attenmask); aclDestroyTensor(softmaxMax); aclDestroyTensor(softmaxSum); aclDestroyTensor(attentionIn); aclDestroyTensor(dq); aclDestroyTensor(dqRope); aclDestroyTensor(dk); aclDestroyTensor(dkRope); aclDestroyTensor(dv); // 7. 释放device资源 aclrtFree(qDeviceAddr); aclrtFree(qRopeDeviceAddr); aclrtFree(kDeviceAddr); aclrtFree(kRopeDeviceAddr); aclrtFree(vDeviceAddr); aclrtFree(dxDeviceAddr); aclrtFree(attenmaskDeviceAddr); aclrtFree(softmaxMaxDeviceAddr); aclrtFree(softmaxSumDeviceAddr); aclrtFree(attentionInDeviceAddr); aclrtFree(dqDeviceAddr); aclrtFree(dqRopeDeviceAddr); aclrtFree(dkDeviceAddr); aclrtFree(dkRopeDeviceAddr); aclrtFree(dvDeviceAddr); if (workspaceSize > 0) { aclrtFree(workspaceAddr); } aclrtDestroyStream(stream); aclrtResetDevice(deviceId); aclFinalize(); return 0; }

【免费下载链接】ops-transformer本项目是CANN提供的transformer类大模型算子库，实现网络在NPU上加速计算。项目地址: https://gitcode.com/cann/ops-transformer