291 lines
10 KiB
C++
291 lines
10 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/nonlinear_fuc_ops_declare.h"
|
||
|
||
namespace mindspore::transform {
|
||
// Relu
|
||
INPUT_MAP(Relu) = {{1, INPUT_DESC(x)}};
|
||
//输入映射，x的索引为1
|
||
ATTR_MAP(Relu) = EMPTY_ATTR_MAP;
|
||
//属性映射，空
|
||
OUTPUT_MAP(Relu) = {{0, OUTPUT_DESC(y)}};
|
||
//输出映射，y的索引为0
|
||
REG_ADPT_DESC(Relu, prim::kPrimRelu->name(), ADPT_DESC(Relu))
|
||
// 注册Relu操作的适配器描述prim::kPrimRelu->name()
|
||
|
||
// ReluV2
|
||
INPUT_MAP(ReluV2) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(ReluV2) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(ReluV2) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(mask)}};
|
||
// 输出映射，y的索引为0，mask索引为1
|
||
REG_ADPT_DESC(ReluV2, kNameReluV2, ADPT_DESC(ReluV2))
|
||
// 注册ReluV2操作的适配器描述kNameReluV2
|
||
|
||
// Elu
|
||
INPUT_MAP(Elu) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Elu) = {{"alpha", ATTR_DESC(alpha, AnyTraits<float>())}};
|
||
// 属性映射，属性"alpha"的类型为float
|
||
OUTPUT_MAP(Elu) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Elu, kNameElu, ADPT_DESC(Elu))
|
||
// 注册Elu操作的适配器描述kNameElu
|
||
|
||
// EluGrad
|
||
INPUT_MAP(EluGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(activations)}};
|
||
// 输入映射，有两个，x的索引为1，activations索引为2
|
||
ATTR_MAP(EluGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(EluGrad) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(EluGrad, kNameEluGrad, ADPT_DESC(EluGrad))
|
||
// 注册EluGrad操作的适配器描述kNameEluGrad
|
||
|
||
// PRelu
|
||
INPUT_MAP(PRelu) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(weight)}};
|
||
// 输入映射，有两个，x的索引为1，weight索引为2
|
||
ATTR_MAP(PRelu) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(PRelu) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(PRelu, kNamePrelu, ADPT_DESC(PRelu))
|
||
// 注册PRelu操作的适配器描述kNamePrelu
|
||
|
||
// PReluGrad
|
||
INPUT_MAP(PReluGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(features)}, {3, INPUT_DESC(weights)}};
|
||
// 输入映射，有三个，grads的索引为1，features索引为2，weights索引为3
|
||
ATTR_MAP(PReluGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(PReluGrad) = {{0, OUTPUT_DESC(dx)}, {1, OUTPUT_DESC(da)}};
|
||
// 输出映射，dx的索引为0，da索引为1
|
||
REG_ADPT_DESC(PReluGrad, kNamePreluGrad, ADPT_DESC(PReluGrad))
|
||
// 注册PReluGrad操作的适配器描述kNamePreluGrad
|
||
|
||
// Selu
|
||
INPUT_MAP(Selu) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Selu) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Selu) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Selu, kNameSelu, ADPT_DESC(Selu))
|
||
// 注册Selu操作的适配器描述kNameSelu
|
||
|
||
// Sigmoid
|
||
INPUT_MAP(Sigmoid) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Sigmoid) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Sigmoid) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Sigmoid, kNameSigmoid, ADPT_DESC(Sigmoid))
|
||
// 注册Sigmoid操作的适配器描述kNameSigmoid
|
||
|
||
// SigmoidGrad
|
||
INPUT_MAP(SigmoidGrad) = {{1, INPUT_DESC(y)}, {2, INPUT_DESC(dy)}};
|
||
// 输入映射，有两个，y的索引为1，dy索引为2
|
||
ATTR_MAP(SigmoidGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(SigmoidGrad) = {{0, OUTPUT_DESC(z)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(SigmoidGrad, kNameSigmoidGrad, ADPT_DESC(SigmoidGrad))
|
||
// 注册SigmoidGrad操作的适配器描述kNameSigmoidGrad
|
||
|
||
// HardSwish
|
||
INPUT_MAP(HardSwish) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(HardSwish) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(HardSwish) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(HardSwish, kNameHSwish, ADPT_DESC(HardSwish))
|
||
// 注册HardSwish操作的适配器描述kNameHSwish
|
||
|
||
// HardSwishGrad
|
||
INPUT_MAP(HardSwishGrad) = {{1, INPUT_DESC(grad)}, {2, INPUT_DESC(x)}};
|
||
// 输入映射，有两个，grad的索引为1，x索引为2
|
||
ATTR_MAP(HardSwishGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(HardSwishGrad) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(HardSwishGrad, kNameHSwishGrad, ADPT_DESC(HardSwishGrad))
|
||
// 注册HardSwishGrad操作的适配器描述kNameHSwishGrad
|
||
|
||
// HSigmoid
|
||
INPUT_MAP(HardSigmoid) = {{1, INPUT_DESC(input_x)}};
|
||
// 输入映射，input_x的索引为1
|
||
ATTR_MAP(HardSigmoid) = {{"alpha", ATTR_DESC(alpha, AnyTraits<float>())},
|
||
{"beta", ATTR_DESC(beta, AnyTraits<float>())}};
|
||
// 属性映射，属性"alpha""beta"的类型为float
|
||
OUTPUT_MAP(HardSigmoid) = {{0, OUTPUT_DESC(output_y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(HardSigmoid, kNameHSigmoid, ADPT_DESC(HardSigmoid))
|
||
// 注册HardSigmoid操作的适配器描述kNameHSigmoid
|
||
|
||
// Relu6
|
||
INPUT_MAP(Relu6) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Relu6) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Relu6) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Relu6, kNameReLU6, ADPT_DESC(Relu6))
|
||
// 注册Relu6操作的适配器描述kNameReLU6
|
||
|
||
// Relu6Grad
|
||
INPUT_MAP(Relu6Grad) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(features)}};
|
||
// 输入映射，有两个，gradients的索引为1，features索引为2
|
||
ATTR_MAP(Relu6Grad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Relu6Grad) = {{0, OUTPUT_DESC(backprops)}};
|
||
// 输出映射，backprops的索引为0
|
||
REG_ADPT_DESC(Relu6Grad, kNameReLU6Grad, ADPT_DESC(Relu6Grad))
|
||
// 注册Relu6Grad操作的适配器描述kNameReLU6Grad
|
||
|
||
// Softsign
|
||
INPUT_MAP(Softsign) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Softsign) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Softsign) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Softsign, kNameSoftsign, ADPT_DESC(Softsign))
|
||
// 注册Softsign操作的适配器描述kNameSoftsign
|
||
|
||
// Softplus
|
||
INPUT_MAP(Softplus) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Softplus) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Softplus) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Softplus, kNameSoftplus, ADPT_DESC(Softplus))
|
||
// 注册Softplus操作的适配器描述 kNameSoftplus
|
||
|
||
// SoftplusGrad
|
||
INPUT_MAP(SoftplusGrad) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(features)}};
|
||
// 输入映射，有两个，gradients的索引为1，features索引为2
|
||
ATTR_MAP(SoftplusGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(SoftplusGrad) = {{0, OUTPUT_DESC(backprops)}};
|
||
// 输出映射，backprops的索引为0
|
||
REG_ADPT_DESC(SoftplusGrad, kNameSoftplusGrad, ADPT_DESC(SoftplusGrad))
|
||
// 注册SoftplusGrad操作的适配器描述kNameSoftplusGrad
|
||
|
||
// ReluGrad
|
||
INPUT_MAP(ReluGrad) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(features)}};
|
||
// 输入映射，有两个，gradients的索引为1，features索引为2
|
||
ATTR_MAP(ReluGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(ReluGrad) = {{0, OUTPUT_DESC(backprops)}};
|
||
// 输出映射，backprops的索引为0
|
||
REG_ADPT_DESC(ReluGrad, prim::kPrimReluGrad->name(), ADPT_DESC(ReluGrad))
|
||
// 注册ReluGrad操作的适配器描述prim::kPrimReluGrad->name()
|
||
|
||
// ReluGradV2
|
||
INPUT_MAP(ReluGradV2) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(mask)}};
|
||
// 输入映射，有两个，gradients的索引为1，mask索引为2
|
||
ATTR_MAP(ReluGradV2) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(ReluGradV2) = {{0, OUTPUT_DESC(backprops)}};
|
||
// 输出映射，backprops的索引为0
|
||
REG_ADPT_DESC(ReluGradV2, kNameReluGradV2, ADPT_DESC(ReluGradV2))
|
||
// 注册ReluGradV2操作的适配器描述kNameReluGradV2
|
||
|
||
// Tanh
|
||
INPUT_MAP(Tanh) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Tanh) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Tanh) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Tanh, prim::kPrimTanh->name(), ADPT_DESC(Tanh))
|
||
// 注册Tanh操作的适配器描述prim::kPrimTanh->name()
|
||
|
||
// TanhGrad
|
||
INPUT_MAP(TanhGrad) = {{1, INPUT_DESC(y)}, {2, INPUT_DESC(dy)}};
|
||
// 输入映射，有两个，y的索引为1，dy索引为2
|
||
ATTR_MAP(TanhGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(TanhGrad) = {{0, OUTPUT_DESC(z)}};
|
||
// 输出映射，z的索引为0
|
||
REG_ADPT_DESC(TanhGrad, prim::kPrimTanhGrad->name(), ADPT_DESC(TanhGrad))
|
||
// 注册NPUTanhGrad操作的适配器描述prim::kPrimTanhGrad->name()
|
||
|
||
// Mish
|
||
INPUT_MAP(Mish) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Mish) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Mish) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Mish, kNameMish, ADPT_DESC(Mish))
|
||
// 注册Mish操作的适配器描述kNameMish
|
||
|
||
// GeLU
|
||
INPUT_MAP(Gelu) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(Gelu) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(Gelu) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(Gelu, prim::kPrimGeLU->name(), ADPT_DESC(Gelu))
|
||
// 注册Gelu操作的适配器描述prim::kPrimGeLU->name()
|
||
|
||
// GeLUGrad
|
||
INPUT_MAP(GeluGrad) = {{1, INPUT_DESC(dy)}, {2, INPUT_DESC(x)}, {3, INPUT_DESC(y)}};
|
||
// 输入映射，有三个，x的索引为1，activations索引为2，y索引为3
|
||
ATTR_MAP(GeluGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(GeluGrad) = {{0, OUTPUT_DESC(z)}};
|
||
// 输出映射，z的索引为0
|
||
REG_ADPT_DESC(GeluGrad, prim::kPrimGeLUGrad->name(), ADPT_DESC(GeluGrad))
|
||
// 注册GeluGrad操作的适配器描述prim::kPrimGeLUGrad->name()
|
||
|
||
// FastGeLU
|
||
INPUT_MAP(FastGelu) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(FastGelu) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(FastGelu) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(FastGelu, prim::kPrimFastGeLU->name(), ADPT_DESC(FastGelu))
|
||
// 注册FastGelu操作的适配器描述 prim::kPrimFastGeLU->name()
|
||
|
||
// FastGeLUGrad
|
||
INPUT_MAP(FastGeluGrad) = {{1, INPUT_DESC(dy)}, {2, INPUT_DESC(x)}};
|
||
// 输入映射，有两个，dy的索引为1，x索引为2
|
||
ATTR_MAP(FastGeluGrad) = EMPTY_ATTR_MAP;
|
||
// 属性映射，空
|
||
OUTPUT_MAP(FastGeluGrad) = {{0, OUTPUT_DESC(z)}};
|
||
// 输出映射，z的索引为0
|
||
REG_ADPT_DESC(FastGeluGrad, prim::kPrimFastGeLUGrad->name(), ADPT_DESC(FastGeluGrad))
|
||
// 注册FastGeluGrad操作的适配器描述 prim::kPrimFastGeLUGrad->name()
|
||
|
||
// LeakyRelu
|
||
INPUT_MAP(LeakyRelu) = {{1, INPUT_DESC(x)}};
|
||
// 输入映射，x的索引为1
|
||
ATTR_MAP(LeakyRelu) = {{"alpha", ATTR_DESC(negative_slope, AnyTraits<float>())}};
|
||
// 属性映射，属性"alpha"的类型为float
|
||
OUTPUT_MAP(LeakyRelu) = {{0, OUTPUT_DESC(y)}};
|
||
// 输出映射，y的索引为0
|
||
REG_ADPT_DESC(LeakyRelu, prim::kPrimLeakyRelu->name(), ADPT_DESC(LeakyRelu))
|
||
// 注册LeakyRelu操作的适配器描述 prim::kPrimLeakyRelu->name()
|
||
} // namespace mindspore::transform
|