316 lines
20 KiB
C++
316 lines
20 KiB
C++
/**
|
||
* Copyright 2019-2021 Huawei Technologies Co., Ltd
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
|
||
#include "transform/graph_ir/op_declare/nn_training_ops_declare.h"
|
||
|
||
namespace mindspore::transform {
|
||
// ApplyMomentum
|
||
INPUT_MAP(ApplyMomentum) = {
|
||
{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(lr)}, {4, INPUT_DESC(grad)}, {5, INPUT_DESC(momentum)}};
|
||
// 输入映射，有四个输入，accum索引为2，lr索引为3，grad索引为4，momentum索引为5
|
||
ATTR_MAP(ApplyMomentum) = {{"use_nesterov", ATTR_DESC(use_nesterov, AnyTraits<bool>())},
|
||
{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有两个属性"use_nesterov""use_locking"，类型未bool型
|
||
OUTPUT_MAP(ApplyMomentum) = {{0, OUTPUT_DESC(var)}};'
|
||
//输出映射，var的索引为0
|
||
REG_ADPT_DESC(ApplyMomentum, kNameApplyMomentum, ADPT_DESC(ApplyMomentum))
|
||
// 注册ApplyMomentum操作的适配器描述kNameApplyMomentum
|
||
//
|
||
// LarsV2Update
|
||
INPUT_MAP(LarsV2Update) = {{1, INPUT_DESC(w)},
|
||
{2, INPUT_DESC(g)},
|
||
{3, INPUT_DESC(w_square_sum)},
|
||
{4, INPUT_DESC(g_square_sum)},
|
||
{5, INPUT_DESC(weight_decay)},
|
||
{6, INPUT_DESC(learning_rate)}};
|
||
// 输入映射，有六个输入，w索引为1，g索引为2，w_square_sum索引为3，g_square_sum索引为4，weight_decay索引为5，learning_rate索引为6
|
||
ATTR_MAP(LarsV2Update) = {{"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())},
|
||
{"hyperpara", ATTR_DESC(hyperpara, AnyTraits<float>())},
|
||
{"use_clip", ATTR_DESC(use_clip, AnyTraits<bool>())}};
|
||
// 属性映射，有三个属性，"epsilon""hyperpara"，类型为float型，"use_clip"类型为bool型
|
||
OUTPUT_MAP(LarsV2Update) = {{0, OUTPUT_DESC(g_new)}};
|
||
// 输出映射，g_new的索引为0
|
||
REG_ADPT_DESC(LarsV2Update, kNameLARSUpdate, ADPT_DESC(LarsV2Update))
|
||
// 注册LarsV2Update操作的适配器描述kNameLARSUpdate
|
||
|
||
// ApplyAdam
|
||
INPUT_MAP(ApplyAdam) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(m)}, {3, INPUT_DESC(v)},
|
||
{4, INPUT_DESC(beta1_power)}, {5, INPUT_DESC(beta2_power)}, {6, INPUT_DESC(lr)},
|
||
{7, INPUT_DESC(beta1)}, {8, INPUT_DESC(beta2)}, {9, INPUT_DESC(epsilon)},
|
||
{10, INPUT_DESC(grad)}};
|
||
// 输入映射，有十个输入，var索引为1，m索引为2，v索引为3，beta1_power索引为4，beta2_power索引为5，lr索引为6
|
||
// betal索引为7，beta2索引为8，epsilon索引为9，grad索引为10
|
||
ATTR_MAP(ApplyAdam) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())},
|
||
{"use_nesterov", ATTR_DESC(use_nesterov, AnyTraits<bool>())}};
|
||
// 属性映射，有两个属性"use_locking""use_nesterov"，类型为bool型
|
||
OUTPUT_MAP(ApplyAdam) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
// ApplyAdamD
|
||
INPUT_MAP(ApplyAdamD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(m)}, {3, INPUT_DESC(v)},
|
||
{4, INPUT_DESC(beta1_power)}, {5, INPUT_DESC(beta2_power)}, {6, INPUT_DESC(lr)},
|
||
{7, INPUT_DESC(beta1)}, {8, INPUT_DESC(beta2)}, {9, INPUT_DESC(epsilon)},
|
||
{10, INPUT_DESC(grad)}};
|
||
// 输入映射，有十个输入，var索引为1，m索引为2，v索引为3，beta1_power索引为4，beta2_power索引为5，lr索引为6
|
||
// betal索引为7，beta2索引为8，epsilon索引为9，grad索引为10
|
||
ATTR_MAP(ApplyAdamD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())},
|
||
{"use_nesterov", ATTR_DESC(use_nesterov, AnyTraits<bool>())}};
|
||
// 属性映射，有两个属性"use_locking""use_nesterov"，类型为bool型
|
||
OUTPUT_MAP(ApplyAdamD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(m)}, {2, OUTPUT_DESC(v)}};
|
||
// 输出映射，共三个，var的索引为0，m索引为1，v索引为2
|
||
REG_ADPT_DESC(ApplyAdamD, kNameApplyAdam, ADPT_DESC(ApplyAdamD))
|
||
// 注册ApplyAdamD操作的适配器描述kNameApplyAdam
|
||
REG_ADPT_DESC(ApplyAdam, kNameApplyAdam, ADPT_DESC(ApplyAdam))
|
||
// 注册ApplyAdam操作的适配器描述kNameApplyAdam
|
||
|
||
// ApplyAdagradD
|
||
INPUT_MAP(ApplyAdagradD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(lr)}, {4, INPUT_DESC(grad)}};
|
||
// 输入映射，有四个输入，var索引为1，accum索引为2，lr索引为3，grad索引为4
|
||
ATTR_MAP(ApplyAdagradD) = {{"update_slots", ATTR_DESC(update_slots, AnyTraits<bool>())},
|
||
{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有两个属性"use_locking""use_nesterov"，类型为bool型
|
||
OUTPUT_MAP(ApplyAdagradD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(accum)}};
|
||
// 输出映射，共两个，var的索引为0，accum索引为1
|
||
REG_ADPT_DESC(ApplyAdagradD, kNameApplyAdagrad, ADPT_DESC(ApplyAdagradD))
|
||
// 注册ApplyAdagradD操作的适配器描述 kNameApplyAdagrad
|
||
//
|
||
// ApplyAdagradV2D
|
||
INPUT_MAP(ApplyAdagradV2D) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(lr)}, {4, INPUT_DESC(grad)}};
|
||
// 输入映射，有四个输入，var索引为1，accum索引为2，lr索引为3，grad索引为4
|
||
ATTR_MAP(ApplyAdagradV2D) = {{"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())},
|
||
{"update_slots", ATTR_DESC(update_slots, AnyTraits<bool>())},
|
||
{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有三个属性，"epsilon"，类型为float型，"update_slots""use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyAdagradV2D) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(accum)}};
|
||
// 输出映射，共两个，var的索引为0，accum索引为1
|
||
REG_ADPT_DESC(ApplyAdagradV2D, kNameApplyAdagradV2D, ADPT_DESC(ApplyAdagradV2D))
|
||
// 注册ApplyAdagradV2D操作的适配器描述 kNameApplyAdagradV2D
|
||
|
||
// ApplyAddSignD
|
||
INPUT_MAP(ApplyAddSignD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(m)}, {3, INPUT_DESC(lr)},
|
||
{4, INPUT_DESC(alpha)}, {5, INPUT_DESC(sign_decay)}, {6, INPUT_DESC(beta)},
|
||
{7, INPUT_DESC(grad)}};
|
||
// 输入映射，有七个输入，var索引为1，m索引为2，lr索引为3，alpha索引为4，sign_decay索引为5，beta索引为6，grad索引为7
|
||
ATTR_MAP(ApplyAddSignD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
//属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyAddSignD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(m)}};
|
||
// 输出映射，共两个，var的索引为0，m索引为1
|
||
REG_ADPT_DESC(ApplyAddSignD, kNameApplyAddSignD, ADPT_DESC(ApplyAddSignD))
|
||
// 注册ApplyAddSignD操作的适配器描述kNameApplyAddSignD
|
||
|
||
// SparseApplyAdagradV2D
|
||
INPUT_MAP(SparseApplyAdagradV2D) = {
|
||
{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(grad)}, {4, INPUT_DESC(indices)}};
|
||
// 输入映射，有四个输入，var索引为1，accum索引为2，grad索引为3，indices索引为4
|
||
ATTR_MAP(SparseApplyAdagradV2D) = {{"lr", ATTR_DESC(lr, AnyTraits<float>())},
|
||
{"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())},
|
||
{"update_slots", ATTR_DESC(update_slots, AnyTraits<bool>())},
|
||
{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有四个属性，"lr""epsilon"，类型为float型，"update_slots""use_locking"类型为bool型
|
||
OUTPUT_MAP(SparseApplyAdagradV2D) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(accum)}};
|
||
// 输出映射，共两个，var的索引为0，accum索引为1
|
||
REG_ADPT_DESC(SparseApplyAdagradV2D, kNameSparseApplyAdagradV2D, ADPT_DESC(SparseApplyAdagradV2D))
|
||
// 注册SparseApplyAdagradV2D操作的适配器描述kNameSparseApplyAdagradV2D
|
||
|
||
// DataFormatDimMap
|
||
INPUT_MAP(DataFormatDimMap) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x索引为1
|
||
ATTR_MAP(DataFormatDimMap) = {{"src_format", ATTR_DESC(src_format, AnyTraits<std::string>())},
|
||
{"dst_format", ATTR_DESC(dst_format, AnyTraits<std::string>())}};
|
||
// 属性映射，有两个属性，"src_format""dst_format"，类型为td::string型
|
||
OUTPUT_MAP(DataFormatDimMap) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(DataFormatDimMap, kNameDataFormatDimMap, ADPT_DESC(DataFormatDimMap))
|
||
// 注册DataFormatDimMap操作的适配器描述kNameDataFormatDimMap
|
||
|
||
// ApplyAdadeltaD
|
||
INPUT_MAP(ApplyAdadeltaD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(accum_update)},
|
||
{4, INPUT_DESC(lr)}, {5, INPUT_DESC(rho)}, {6, INPUT_DESC(epsilon)},
|
||
{7, INPUT_DESC(grad)}};
|
||
// 输入映射，有七个输入，var索引为1，accum索引为2，accum_update索引为3，lr索引为4，rho索引为5，epsilon索引为6，grad索引为7
|
||
ATTR_MAP(ApplyAdadeltaD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyAdadeltaD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(accum)}, {2, OUTPUT_DESC(accum_update)}};
|
||
// 输出映射，共三个，var的索引为0，accum索引为1，accum_update索引为2
|
||
REG_ADPT_DESC(ApplyAdadeltaD, kNameApplyAdadelta, ADPT_DESC(ApplyAdadeltaD))
|
||
// 注册ApplyAdadeltaD操作的适配器描述 kNameApplyAdadelta
|
||
|
||
// ApplyAdaMaxD
|
||
INPUT_MAP(ApplyAdaMaxD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(m)}, {3, INPUT_DESC(v)},
|
||
{4, INPUT_DESC(beta1_power)}, {5, INPUT_DESC(lr)}, {6, INPUT_DESC(beta1)},
|
||
{7, INPUT_DESC(beta2)}, {8, INPUT_DESC(epsilon)}, {9, INPUT_DESC(grad)}};
|
||
// 输入映射，有十个输入，var索引为1，m索引为2，v索引为3，beta1_power索引为4，lr索引为5
|
||
// betal索引为6，beta2索引为7，epsilon索引为8，grad索引为9
|
||
ATTR_MAP(ApplyAdaMaxD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyAdaMaxD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(m)}, {2, OUTPUT_DESC(v)}};
|
||
// 输出映射，共三个，var的索引为0，m索引为1，v索引为2
|
||
REG_ADPT_DESC(ApplyAdaMaxD, kNameApplyAdaMax, ADPT_DESC(ApplyAdaMaxD))
|
||
// 注册ApplyAdaMaxD操作的适配器描述 kNameApplyAdaMax
|
||
|
||
// ApplyGradientDescent
|
||
INPUT_MAP(ApplyGradientDescent) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(alpha)}, {3, INPUT_DESC(delta)}};
|
||
// 输入映射，有三个输入，var索引为1，alpha索引为2，delta索引为3
|
||
ATTR_MAP(ApplyGradientDescent) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyGradientDescent) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
REG_ADPT_DESC(ApplyGradientDescent, kNameApplyGradientDescent, ADPT_DESC(ApplyGradientDescent))
|
||
// 注册ApplyGradientDescent操作的适配器描述kNameApplyGradientDescent
|
||
|
||
// ApplyPowerSignD
|
||
INPUT_MAP(ApplyPowerSignD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(m)}, {3, INPUT_DESC(lr)},
|
||
{4, INPUT_DESC(logbase)}, {5, INPUT_DESC(sign_decay)}, {6, INPUT_DESC(beta)},
|
||
{7, INPUT_DESC(grad)}};
|
||
// 输入映射，有七个输入，var索引为1，m索引为2，lr索引为3，logbase索引为4，sign_decay索引为5
|
||
// beta索引为6，grad索引为7
|
||
ATTR_MAP(ApplyPowerSignD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyPowerSignD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(m)}};
|
||
// 输出映射，共两个，var的索引为0，m索引为1
|
||
REG_ADPT_DESC(ApplyPowerSignD, kNameApplyPowerSign, ADPT_DESC(ApplyPowerSignD))
|
||
// 注册ApplyPowerSignD操作的适配器描述kNameApplyPowerSign
|
||
|
||
// ApplyProximalGradientDescent
|
||
INPUT_MAP(ApplyProximalGradientDescent) = {
|
||
{1, INPUT_DESC(var)}, {2, INPUT_DESC(alpha)}, {3, INPUT_DESC(l1)}, {4, INPUT_DESC(l2)}, {5, INPUT_DESC(delta)}};
|
||
// 输入映射，有五个输入，var索引为1，alpha索引为2，l1索引为3，l2索引为4，delta索引为5
|
||
ATTR_MAP(ApplyProximalGradientDescent) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyProximalGradientDescent) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
REG_ADPT_DESC(ApplyProximalGradientDescent, kNameApplyProximalGradientDescent, ADPT_DESC(ApplyProximalGradientDescent))
|
||
// 注册ApplyProximalGradientDescent操作的适配器描述kNameApplyProximalGradientDescent
|
||
//
|
||
// SGD
|
||
INPUT_MAP(SGD) = {{1, INPUT_DESC(parameters)}, {2, INPUT_DESC(gradient)}, {3, INPUT_DESC(learning_rate)},
|
||
{4, INPUT_DESC(accum)}, {5, INPUT_DESC(momentum)}, {6, INPUT_DESC(stat)}};
|
||
// 输入映射，有六个输入，parameters索引为1，gradient索引为2，lr索引为3，logbase索引为4，sign_decay索引为5，stat索引为6
|
||
ATTR_MAP(SGD) = {{"dampening", ATTR_DESC(dampening, AnyTraits<float>())},
|
||
{"weight_decay", ATTR_DESC(weight_decay, AnyTraits<float>())},
|
||
{"nesterov", ATTR_DESC(nesterov, AnyTraits<bool>())}};
|
||
// 属性映射，有三个属性，"dampening""weight_decay"类型为float型，"nesterov"类型为bool型
|
||
OUTPUT_MAP(SGD) = {{0, OUTPUT_DESC(parameters)}};
|
||
// 输出映射，parameters的索引为0
|
||
REG_ADPT_DESC(SGD, kNameSGD, ADPT_DESC(SGD))
|
||
// 注册SGD操作的适配器描述kNameSGD
|
||
|
||
// SparseApplyAdagradD
|
||
INPUT_MAP(SparseApplyAdagradD) = {
|
||
{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(grad)}, {4, INPUT_DESC(indices)}};
|
||
// 输入映射，有四个输入，var索引为1，accum索引为2，grad索引为3，indices索引为4
|
||
ATTR_MAP(SparseApplyAdagradD) = {{"lr", ATTR_DESC(lr, AnyTraits<float>())},
|
||
{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有两个属性，"lr"类型为float型，"use_locking"类型为bool型
|
||
OUTPUT_MAP(SparseApplyAdagradD) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
REG_ADPT_DESC(SparseApplyAdagradD, kNameSparseApplyAdagrad, ADPT_DESC(SparseApplyAdagradD))
|
||
// 注册SparseApplyAdagradD操作的适配器描述 kNameSparseApplyAdagrad
|
||
|
||
// ApplyProximalAdagradD
|
||
INPUT_MAP(ApplyProximalAdagradD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(lr)},
|
||
{4, INPUT_DESC(l1)}, {5, INPUT_DESC(l2)}, {6, INPUT_DESC(grad)}};
|
||
// 输入映射，有六个输入，var索引为1，accum索引为2，lr索引为3，l1索引为4，l2索引为5，grad索引为6
|
||
ATTR_MAP(ApplyProximalAdagradD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyProximalAdagradD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(accum)}};
|
||
// 输出映射，var的索引为0，accum的索引为1
|
||
REG_ADPT_DESC(ApplyProximalAdagradD, kNameApplyProximalAdagrad, ADPT_DESC(ApplyProximalAdagradD))
|
||
// 注册ApplyProximalAdagradD操作的适配器描述kNameApplyProximalAdagrad
|
||
//
|
||
// SparseApplyProximalAdagradD
|
||
INPUT_MAP(SparseApplyProximalAdagradD) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(lr)},
|
||
{4, INPUT_DESC(l1)}, {5, INPUT_DESC(l2)}, {6, INPUT_DESC(grad)},
|
||
{7, INPUT_DESC(indices)}};
|
||
// 输入映射，有七个输入，var索引为1，accum索引为2，lr索引为3，l1索引为4，l2索引为5，grad索引为6，indices索引为7
|
||
ATTR_MAP(SparseApplyProximalAdagradD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(SparseApplyProximalAdagradD) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(accum)}};
|
||
// 输出映射，var的索引为0，accum的索引为1
|
||
REG_ADPT_DESC(SparseApplyProximalAdagradD, kNameSparseApplyProximalAdagradD, ADPT_DESC(SparseApplyProximalAdagradD))
|
||
// 注册SparseApplyProximalAdagradD操作的适配器描述kNameSparseApplyProximalAdagradD
|
||
|
||
// SparseApplyFtrlD
|
||
INPUT_MAP(SparseApplyFtrlD) = {{1, INPUT_DESC(var)},
|
||
{2, INPUT_DESC(accum)},
|
||
{3, INPUT_DESC(linear)},
|
||
{4, INPUT_DESC(grad)},
|
||
{5, INPUT_DESC(indices)}};
|
||
// 输入映射，有五个输入，var索引为1，accum索引为2，linear索引为3，grad索引为4，indices索引为5
|
||
ATTR_MAP(SparseApplyFtrlD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())},
|
||
{"lr", ATTR_DESC(lr, AnyTraits<float>())},
|
||
{"l1", ATTR_DESC(l1, AnyTraits<float>())},
|
||
{"l2", ATTR_DESC(l2, AnyTraits<float>())},
|
||
{"lr_power", ATTR_DESC(lr_power, AnyTraits<float>())}};
|
||
// 属性映射，有五个属性，"use_locking""lr""l1""l2""lr_power"类型为float型
|
||
OUTPUT_MAP(SparseApplyFtrlD) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
REG_ADPT_DESC(SparseApplyFtrlD, kNameSparseApplyFtrlD, ADPT_DESC(SparseApplyFtrlD))
|
||
// 注册SparseApplyFtrlD操作的适配器描述kNameSparseApplyFtrlD
|
||
|
||
// SparseApplyFtrlV2D
|
||
INPUT_MAP(SparseApplyFtrlV2D) = {{1, INPUT_DESC(var)},
|
||
{2, INPUT_DESC(accum)},
|
||
{3, INPUT_DESC(linear)},
|
||
{4, INPUT_DESC(grad)},
|
||
{5, INPUT_DESC(indices)}};
|
||
// 输入映射，有五个输入，var索引为1，accum索引为2，linear索引为3，grad索引为4，indices索引为5
|
||
ATTR_MAP(SparseApplyFtrlV2D) = {{"lr", ATTR_DESC(lr, AnyTraits<float>())}, {"l1", ATTR_DESC(l1, AnyTraits<float>())}};
|
||
// 属性映射，有两个属性，"l1""l2"类型为float型
|
||
OUTPUT_MAP(SparseApplyFtrlV2D) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(accum)}, {2, OUTPUT_DESC(linear)}};
|
||
// 输出映射，var的索引为0，accum的索引为1，linear索引为2
|
||
REG_ADPT_DESC(SparseApplyFtrlV2D, kNameSparseApplyFtrlV2D, ADPT_DESC(SparseApplyFtrlV2D))
|
||
// 注册SparseApplyFtrlV2D操作的适配器描述 kNameSparseApplyFtrlV2D
|
||
|
||
// ApplyFtrl
|
||
INPUT_MAP(ApplyFtrl) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(linear)},
|
||
{4, INPUT_DESC(grad)}, {5, INPUT_DESC(lr)}, {6, INPUT_DESC(l1)},
|
||
{7, INPUT_DESC(l2)}, {8, INPUT_DESC(lr_power)}};
|
||
// 输入映射，有八个输入，var索引为1，accum索引为2，linear索引为3，grad索引为4，lr索引为5，l1索引为6，l2索引为7，lr_power索引为8
|
||
ATTR_MAP(ApplyFtrl) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型
|
||
OUTPUT_MAP(ApplyFtrl) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
REG_ADPT_DESC(ApplyFtrl, kNameApplyFtrl, ADPT_DESC(ApplyFtrl))
|
||
// 注册ApplyFtrl操作的适配器描述kNameApplyFtrl
|
||
|
||
// ApplyRMSPropD
|
||
INPUT_MAP(ApplyRMSPropD) = {
|
||
{1, INPUT_DESC(var)}, {2, INPUT_DESC(ms)}, {3, INPUT_DESC(mom)}, {4, INPUT_DESC(lr)}, {5, INPUT_DESC(grad)}};
|
||
// 输入映射，有五个输入，var索引为1，ms索引为2，mom索引为3，lr索引为4，grad索引为5
|
||
INPUT_ATTR_MAP(ApplyRMSPropD) = {{6, ATTR_DESC(rho, AnyTraits<float>())},
|
||
{7, ATTR_DESC(momentum, AnyTraits<float>())},
|
||
{8, ATTR_DESC(epsilon, AnyTraits<float>())}};
|
||
//输入属性映射，共3个，rho索引为6，momentum索引为7，epsilon索引为8
|
||
ATTR_MAP(ApplyRMSPropD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}}
|
||
// 属性映射，有一个属性，"use_locking"类型为bool型;
|
||
OUTPUT_MAP(ApplyRMSPropD) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
REG_ADPT_DESC(ApplyRMSPropD, kNameApplyRMSProp, ADPT_DESC(ApplyRMSPropD))
|
||
// 注册ApplyRMSPropD操作的适配器描述 kNameApplyRMSProp
|
||
|
||
// ApplyCenteredRMSProp
|
||
INPUT_MAP(ApplyCenteredRMSProp) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(mg)}, {3, INPUT_DESC(ms)},
|
||
{4, INPUT_DESC(mom)}, {5, INPUT_DESC(grad)}, {6, INPUT_DESC(lr)},
|
||
{7, INPUT_DESC(rho)}, {8, INPUT_DESC(momentum)}, {9, INPUT_DESC(epsilon)}};
|
||
// 输入映射，有九个输入，var索引为1，mg索引为2，ms索引为3，mom索引为4，grad索引为5，lr索引为6，rho索引为7，momentum索引为8，epsilon索引为9
|
||
ATTR_MAP(ApplyCenteredRMSProp) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};
|
||
// 输入属性映射，rho索引为6，momentum索引为7，epsilon索引为8
|
||
OUTPUT_MAP(ApplyCenteredRMSProp) = {{0, OUTPUT_DESC(var)}};
|
||
// 输出映射，var的索引为0
|
||
REG_ADPT_DESC(ApplyCenteredRMSProp, kNameApplyCenteredRMSProp, ADPT_DESC(ApplyCenteredRMSProp))
|
||
// 注册ApplyCenteredRMSProp操作的适配器描述kNameApplyCenteredRMSProp
|
||
} // namespace mindspore::transform
|