nnrt/v1_0/NodeAttrTypes.idl

/*
 * Copyright (c) 2022 Huawei Device 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.
 */

package ohos.hdi.nnrt.v1_0;

import ohos.hdi.nnrt.v1_0.NnrtTypes;

struct Activation
{
    enum ActivationType activationType;
    float alpha;
    float minVal;
    float maxVal;
    boolean approximate;
};

struct AddFusion
{
    enum ActivationType activationType;
};

struct ArgMaxFusion
{
    long axis;
    long topK;
    boolean keepDims;
    boolean outMaxValue;
};

struct AvgPoolFusion
{
    long[] kernelSize;
    long[] strides;
    long[] pad;
    enum PadMode padMode;
    enum RoundMode roundMode;
    enum Format format;
    boolean global;
    enum ActivationType activationType;
};

struct BatchToSpaceND
{
    long[] blockShape;
    long[][] crops;
};

struct BiasAdd
{
};

struct Cast
{
};

struct Concat
{
    long axis;
};

struct Conv2DFusion
{
    long[] kernelSize;
    long[] stride;
    long[] dilation;
    enum PadMode padMode;
    long[] padList;
    long group;
    long inChannel;
    long outChannel;
    enum ActivationType activationType;
};

struct Conv2dTransposeFusion
{
    long[] kernelSize;
    long[] stride;
    long[] dilation;
    enum PadMode padMode;
    long[] padList;
    long group;
    long inChannel;
    long outChannel;
    enum ActivationType activationType;
    long[] outputPaddings;
};

struct DivFusion
{
    enum ActivationType activationType;
};

struct Eltwise
{
    enum EltwiseMode mode;
};

struct ExpandDims
{
};

struct Fill
{
};

struct FullConnection
{
    boolean hasBias;
    boolean useAxis;
    long axis;
    enum ActivationType activationType;
};

struct FusedBatchNorm
{
    float epsilon;
};

struct Gather
{
};

struct LayerNormFusion
{
    long beginNormAxis;
    float epsilon;
    boolean elementwiseAffine;
    long beginParamsAxis;
};

struct LessEqual
{
};

struct MatMulFusion
{
    boolean transposeA;
    boolean transposeB;
    enum ActivationType activationType;
};

struct Maximum
{
};

struct MaxPoolFusion
{
    long[] kernelSize;
    long[] strides;
    long[] pad;
    enum PadMode padMode;
    enum Format format;
    boolean global;
    enum ActivationType activationType;
};

struct MulFusion
{
    enum ActivationType activationType;
};

struct OneHot
{
    long axis;
};

struct PadFusion
{
    long[][] paddings;
    enum PaddingMode paddingMode;
    float constantValue;
};

struct PowFusion
{
    float scale;
    float shift;
};

struct PReLUFusion
{
    boolean channelShared;
};

struct QuantDTypeCast
{
    long srcT;
    long dstT;
};

struct ReduceFusion
{
    boolean keepDims;
    enum ReduceMode mode;
    boolean reduceToEnd;
    float coeff;
};

struct Reshape
{
};

struct Resize
{
    enum ResizeMethod method;
    long newHeight;
    long newWidth;
    boolean preserveAspectRatio;
    enum CoordinateTransformMode coordinateTransformMode;
    float cubicCoeff;
    long excludeOutside;
    float extrapolationValue;
    enum NearestMode nearestMode;
};

struct Rsqrt
{
};

struct ScaleFusion
{
    long axis;
    enum ActivationType activationType;
};

struct Shape
{
};

struct SliceFusion
{
    long[] axes;
};

struct Softmax
{
    long[] axis;
};

struct SpaceToBatchND
{
    long[] blockShape;
    long[][] paddings;
};

struct Split
{
    long outputNum;
    long[] sizeSplits;
    long axis;
};

struct Sqrt
{
};

struct SquaredDifference
{
};

struct Squeeze
{
    long[] axis;
};

struct Stack
{
    long axis;
};

struct StridedSlice
{
    long beginMask;
    long endMask;
    long ellipsisMask;
    long newAxisMask;
    long shrinkAxisMask;
};

struct SubFusion
{
    enum ActivationType activationType;
};

struct TileFusion
{
    long[] dims;
};

struct TopKFusion
{
    boolean sorted;
    long axis;
};

struct Transpose
{
};

struct Unsqueeze
{
    long[] axis;
};