704 lines
21 KiB
C++
704 lines
21 KiB
C++
/**
|
|
* \brief An serial of structs and functions to store and parse attributes of operations
|
|
* The member of variables of returned struct are guaranteed to be initialized
|
|
* \author Ryan Han, Yuhan Ma, Nan Zhou
|
|
* \copyright 2019 Kneron Inc. All right reserved.
|
|
*/
|
|
#ifndef PIANO_DYNASTY_INCLUDE_PARSER_ATTRIBUTEPARSER_H_
|
|
#define PIANO_DYNASTY_INCLUDE_PARSER_ATTRIBUTEPARSER_H_
|
|
|
|
#include <vector>
|
|
|
|
#include "graph/node.h"
|
|
#include "graph/node_list.h"
|
|
#include "utils.h"
|
|
namespace dynasty {
|
|
namespace parser {
|
|
using namespace dynasty::common;
|
|
/**
|
|
* @brief The basic attributes of an operation. Children structs could extend the base class to add special attributes if
|
|
* necessary.
|
|
* @note a operation will always have a single output and potential multiple inputs,
|
|
* all parse function should initialize the basic attributes
|
|
*/
|
|
struct Attribute {
|
|
std::vector<BCHW> in_bchws_;
|
|
std::vector<uint32_t> in_pixel_sizes_;
|
|
|
|
BCHW out_bchw_;
|
|
uint32_t out_pixel_size_;
|
|
explicit Attribute(const Node *n);
|
|
};
|
|
|
|
Attribute parse(const Node *node);
|
|
|
|
struct ArgMaxAttribute : Attribute {
|
|
int axis_ = 0;
|
|
int keepdims_ = 1;
|
|
int select_last_index_ = 0;
|
|
explicit ArgMaxAttribute(const ArgMaxNode *n);
|
|
explicit ArgMaxAttribute(const ArgMinNode *n);
|
|
};
|
|
|
|
ArgMaxAttribute parse(const ArgMaxNode *n);
|
|
using ArgMinAttribute = ArgMaxAttribute;
|
|
ArgMinAttribute parse(const ArgMinNode *n);
|
|
|
|
|
|
// This is to calculate the space for broadcast if needed
|
|
struct ExpandAttribute : Attribute {
|
|
uint32_t broadcast_first_size; // broadcast first matrix size
|
|
|
|
explicit ExpandAttribute(const ExpandNode *n);
|
|
};
|
|
|
|
ExpandAttribute parse(const ExpandNode *n);
|
|
|
|
struct BatchNormalizationAttribute : Attribute {
|
|
float epsilon_; // value to avoid 0 division
|
|
float momentum_; // variable factor
|
|
explicit BatchNormalizationAttribute(const BatchNormalizationNode *n);
|
|
};
|
|
|
|
BatchNormalizationAttribute parse(const BatchNormalizationNode *n);
|
|
|
|
struct BitShiftAttribute : Attribute {
|
|
uint32_t broadcast_first_size; // broadcast first matrix size
|
|
std::string direction_; // direction to shift bits
|
|
explicit BitShiftAttribute(const BitShiftNode *n);
|
|
};
|
|
|
|
BitShiftAttribute parse(const BitShiftNode *n);
|
|
|
|
struct CastAttribute : Attribute {
|
|
int to_; // data type to cast to
|
|
explicit CastAttribute(const CastNode *n);
|
|
};
|
|
|
|
CastAttribute parse(const CastNode *n);
|
|
|
|
struct ClipAttribute : Attribute {
|
|
float max_; // upper bound of interval
|
|
float min_; // lower bound of interval
|
|
explicit ClipAttribute(const ClipNode *n);
|
|
};
|
|
|
|
ClipAttribute parse(const ClipNode *n);
|
|
|
|
struct ConvAttribute : Attribute {
|
|
std::string pad_type_;
|
|
std::vector<int> dilations_;
|
|
std::vector<int> kernel_;
|
|
std::vector<int> pads_;
|
|
std::vector<int> strides_;
|
|
uint32_t group_;
|
|
uint32_t stride_h_;
|
|
uint32_t stride_w_;
|
|
uint32_t out_top_pad_;
|
|
uint32_t out_bottom_pad_;
|
|
uint32_t out_left_pad_;
|
|
uint32_t out_right_pad_;
|
|
explicit ConvAttribute(const ConvNode *n);
|
|
explicit ConvAttribute(const ConvIntegerNode *n);
|
|
explicit ConvAttribute(const ConvTransposeNode *n);
|
|
};
|
|
|
|
ConvAttribute parse(const ConvNode *n);
|
|
using ConvTransposeAttribute = ConvAttribute; ConvTransposeAttribute parse(const ConvTransposeNode *n);
|
|
using ConvIntegerAttribute = ConvAttribute; ConvIntegerAttribute parse(const ConvIntegerNode *n);
|
|
|
|
struct KneronUpsampleZeroFillAttribute : Attribute {
|
|
std::vector<int> upsample_scale;
|
|
explicit KneronUpsampleZeroFillAttribute(const KneronUpsampleZeroFillNode *n);
|
|
};
|
|
|
|
KneronUpsampleZeroFillAttribute parse(const KneronUpsampleZeroFillNode *n);
|
|
|
|
struct KneronChannelSplitAttribute : Attribute {
|
|
std::string mode;
|
|
explicit KneronChannelSplitAttribute(const KneronChannelSplitNode *n);
|
|
};
|
|
|
|
KneronChannelSplitAttribute parse(const KneronChannelSplitNode *n);
|
|
|
|
struct KneronChannelShuffleAttribute : Attribute {
|
|
int group;
|
|
std::string mode;
|
|
explicit KneronChannelShuffleAttribute(const KneronChannelShuffleNode *n);
|
|
};
|
|
|
|
KneronChannelShuffleAttribute parse(const KneronChannelShuffleNode *n);
|
|
|
|
|
|
struct ConcatAttribute : Attribute {
|
|
int axis_; // axis to concatenate on
|
|
explicit ConcatAttribute(const ConcatNode *n);
|
|
};
|
|
|
|
ConcatAttribute parse(const ConcatNode *n);
|
|
|
|
struct CompressAttribute : Attribute {
|
|
int axis_; // axis to concatenate on
|
|
bool axis_set_;
|
|
explicit CompressAttribute(const CompressNode *n);
|
|
};
|
|
|
|
CompressAttribute parse(const CompressNode *n);
|
|
|
|
struct CumSumAttribute : Attribute {
|
|
int exclusive_;
|
|
int reverse_;
|
|
explicit CumSumAttribute(const CumSumNode *n);
|
|
};
|
|
|
|
CumSumAttribute parse(const CumSumNode *n);
|
|
|
|
struct CenterCropPadAttribute : Attribute {
|
|
std::vector<int> axes_;
|
|
explicit CenterCropPadAttribute(const CenterCropPadNode *n);
|
|
};
|
|
|
|
CenterCropPadAttribute parse(const CenterCropPadNode *n);
|
|
|
|
struct DepthToSpaceAttribute : Attribute {
|
|
uint32_t blocksize_; // size of blocks to be moved
|
|
std::string mode_; // type of rearrangement
|
|
explicit DepthToSpaceAttribute(const DepthToSpaceNode *n);
|
|
explicit DepthToSpaceAttribute(const SpaceToDepthNode *n);
|
|
};
|
|
|
|
DepthToSpaceAttribute parse(const DepthToSpaceNode *n);
|
|
using SpaceToDepthAttribute = DepthToSpaceAttribute; //SpaceToDepthAttribute parse(const SpaceToDepthNode *n);
|
|
|
|
struct DequantizeLinearAttribute : Attribute {
|
|
int axis_;
|
|
explicit DequantizeLinearAttribute(const DequantizeLinearNode *n);
|
|
};
|
|
|
|
DequantizeLinearAttribute parse(const DequantizeLinearNode *n);
|
|
|
|
struct GroupNormalizationAttribute : Attribute {
|
|
// int axis_;
|
|
float epsilon_;
|
|
int num_groups_;
|
|
explicit GroupNormalizationAttribute(const GroupNormalizationNode *n);
|
|
};
|
|
|
|
GroupNormalizationAttribute parse(const GroupNormalizationNode *n);
|
|
|
|
struct EyeLikeAttribute : Attribute {
|
|
// int axis_;
|
|
float dtype_;
|
|
int k_;
|
|
explicit EyeLikeAttribute(const EyeLikeNode *n);
|
|
};
|
|
|
|
EyeLikeAttribute parse(const EyeLikeNode *n);
|
|
|
|
struct EluAttribute : Attribute {
|
|
float alpha_; // coefficient for function
|
|
explicit EluAttribute(const LeakyReluNode *n);
|
|
explicit EluAttribute(const EluNode *n);
|
|
explicit EluAttribute(const ThresholdedReluNode *n);
|
|
explicit EluAttribute(const CeluNode *n);
|
|
};
|
|
|
|
EluAttribute parse(EluNode *n);
|
|
using CeluAttribute = EluAttribute; CeluAttribute parse(const CeluNode *n);
|
|
using LeakyReluAttribute = EluAttribute; LeakyReluAttribute parse(const LeakyReluNode *n);
|
|
using ThresholdedReluAttribute = EluAttribute; ThresholdedReluAttribute parse(const ThresholdedReluNode *n);
|
|
|
|
struct EinsumAttribute: Attribute{
|
|
string equation_;
|
|
explicit EinsumAttribute(const EinsumNode* n) : Attribute(n), equation_(n->equation()) {}
|
|
};
|
|
|
|
struct GatherAttribute : Attribute {
|
|
int axis_; // axis to gather on
|
|
explicit GatherAttribute(const GatherNode *n);
|
|
explicit GatherAttribute(const GatherElementsNode *n);
|
|
};
|
|
|
|
GatherAttribute parse(GatherNode *n);
|
|
using GatherElementsAttribute = GatherAttribute; GatherElementsAttribute parse(const GatherElementsNode *n);
|
|
|
|
struct GatherNDAttribute : Attribute {
|
|
int batch_dims_; // axis to gather on
|
|
explicit GatherNDAttribute(const GatherNDNode *n);
|
|
};
|
|
|
|
GatherNDAttribute parse(GatherNDNode *n);
|
|
|
|
struct GemmAttribute : Attribute {
|
|
float alpha_;
|
|
float beta_;
|
|
int transA_;
|
|
int transB_;
|
|
explicit GemmAttribute(const GemmNode *n);
|
|
};
|
|
|
|
GemmAttribute parse(const GemmNode *n);
|
|
|
|
struct GridSampleAttribute : Attribute {
|
|
int align_corners_;
|
|
std::string mode_;
|
|
std::string padding_mode_;
|
|
explicit GridSampleAttribute(const GridSampleNode *n);
|
|
};
|
|
|
|
GridSampleAttribute parse(const GridSampleNode *n);
|
|
|
|
struct HardSigmoidAttribute : Attribute {
|
|
float alpha_; // coefficient
|
|
float beta_; // coefficient
|
|
explicit HardSigmoidAttribute(const HardSigmoidNode *n);
|
|
};
|
|
|
|
HardSigmoidAttribute parse(const HardSigmoidNode *n);
|
|
|
|
struct InstanceNormalizationAttribute : Attribute {
|
|
float epsilon_; // value to avoid 0 division
|
|
explicit InstanceNormalizationAttribute(const InstanceNormalizationNode *n);
|
|
};
|
|
|
|
InstanceNormalizationAttribute parse(const InstanceNormalizationNode *n);
|
|
|
|
struct IsInfAttribute : Attribute {
|
|
int detect_negative_;
|
|
int detect_positive_;
|
|
explicit IsInfAttribute(const IsInfNode *n);
|
|
};
|
|
|
|
IsInfAttribute parse(const IsInfNode *n);
|
|
|
|
struct NegativeLogLikelihoodLossAttribute : Attribute {
|
|
int ignore_index_;
|
|
string reduction_;
|
|
explicit NegativeLogLikelihoodLossAttribute(const NegativeLogLikelihoodLossNode *n);
|
|
};
|
|
|
|
NegativeLogLikelihoodLossAttribute parse(const NegativeLogLikelihoodLossNode *n);
|
|
|
|
struct LpNormAttribute : Attribute {
|
|
int axis_; // axis to apply normalization
|
|
int p_; // order of normalization
|
|
explicit LpNormAttribute(const GlobalLpPoolNode *n);
|
|
explicit LpNormAttribute(const LpNormalizationNode *n);
|
|
};
|
|
|
|
using GlobalLpPoolAttribute = LpNormAttribute; LpNormAttribute parse(const GlobalLpPoolNode *n);
|
|
using LpNormalizationAttribute = LpNormAttribute; LpNormalizationAttribute parse(const LpNormalizationNode *n);
|
|
|
|
struct KneronDownSampleAttribute : Attribute {
|
|
uint32_t top_pad_;
|
|
uint32_t bottom_pad_;
|
|
uint32_t left_pad_;
|
|
uint32_t right_pad_;
|
|
uint32_t stride_h_;
|
|
uint32_t stride_w_;
|
|
Shape offsets_;
|
|
explicit KneronDownSampleAttribute(const KneronDownSampleNode *n);
|
|
};
|
|
|
|
KneronDownSampleAttribute parse(const KneronDownSampleNode *n);
|
|
|
|
struct KneronRollAttribute : Attribute {
|
|
Shape axes_;
|
|
Shape shifts_;
|
|
explicit KneronRollAttribute(const KneronRollNode *n);
|
|
};
|
|
|
|
KneronRollAttribute parse(const KneronRollNode *n);
|
|
|
|
struct KneronSpaceToDepthAttribute : Attribute {
|
|
int blocksize_;
|
|
string mode_;
|
|
explicit KneronSpaceToDepthAttribute(const KneronSpaceToDepthNode *n);
|
|
};
|
|
|
|
KneronSpaceToDepthAttribute parse(const KneronSpaceToDepthNode *n);
|
|
|
|
struct LpPoolAttribute : Attribute {
|
|
string auto_pad_;
|
|
int ceil_mode_;
|
|
std::vector<int> dilations_;
|
|
std::vector<int> kernel_shape_;
|
|
int p_;
|
|
std::vector<int> pads_;
|
|
std::vector<int> strides_;
|
|
explicit LpPoolAttribute(const LpPoolNode *n);
|
|
};
|
|
|
|
LpPoolAttribute parse(const LpPoolNode *n);
|
|
|
|
struct LayerNormalizationAttribute : Attribute {
|
|
int axis_;
|
|
float epsilon_;
|
|
int stash_type_;
|
|
explicit LayerNormalizationAttribute(const LayerNormalizationNode *n);
|
|
};
|
|
|
|
LayerNormalizationAttribute parse(const LayerNormalizationNode *n);
|
|
|
|
struct MelWeightMatrixAttribute : Attribute {
|
|
int output_datatype_ ;
|
|
explicit MelWeightMatrixAttribute(const MelWeightMatrixNode *n);
|
|
};
|
|
|
|
MelWeightMatrixAttribute parse(const MelWeightMatrixNode *n);
|
|
|
|
struct MeanVarianceNormalizationAttribute : Attribute {
|
|
std::vector<int> axes_;
|
|
explicit MeanVarianceNormalizationAttribute(const MeanVarianceNormalizationNode *n);
|
|
};
|
|
|
|
MeanVarianceNormalizationAttribute parse(const MeanVarianceNormalizationNode *n);
|
|
|
|
struct LRNAttribute : Attribute {
|
|
float alpha_; // scaling parameter
|
|
float beta_; // exponent
|
|
float bias_; // bias
|
|
int size_; // number of local channels
|
|
explicit LRNAttribute(const LRNNode *n);
|
|
};
|
|
|
|
LRNAttribute parse(const LRNNode *n);
|
|
|
|
struct MaxRoiPoolAttribute : Attribute {
|
|
uint32_t pooled_shape_h; // output height
|
|
uint32_t pooled_shape_w; // output width
|
|
float spatial_scale_; // coordinate scaling
|
|
Shape roi_;
|
|
explicit MaxRoiPoolAttribute(const MaxRoiPoolNode *n);
|
|
};
|
|
|
|
MaxRoiPoolAttribute parse(const MaxRoiPoolNode *n);
|
|
|
|
struct KneronMaxRoiPoolAttribute : Attribute {
|
|
float spatial_scale_; // coordinate scaling
|
|
Shape roi_;
|
|
Shape roi_kernel_;
|
|
explicit KneronMaxRoiPoolAttribute(const KneronMaxRoiPoolNode *n);
|
|
};
|
|
|
|
KneronMaxRoiPoolAttribute parse(const KneronMaxRoiPoolNode *n);
|
|
|
|
struct MatMulAttribute : Attribute {
|
|
uint32_t broadcast_first_size; // broadcast first matrix size
|
|
uint32_t broadcast_second_size; // broadcast first matrix size
|
|
Shape first_dim;
|
|
Shape second_dim;
|
|
Shape broadcast_first_dim;
|
|
Shape broadcast_second_dim;
|
|
|
|
uint32_t submatrices;
|
|
explicit MatMulAttribute(const MatMulNode *n);
|
|
};
|
|
|
|
MatMulAttribute parse(const MatMulNode *n);
|
|
|
|
struct MysteryAttribute : Attribute {
|
|
std::string op_type_;
|
|
int attr_num_;
|
|
std::vector<std::string> attr_name_;
|
|
std::vector<int> attr_type_;
|
|
std::vector<int> attr_size_;
|
|
std::vector<void*> attr_value_;
|
|
explicit MysteryAttribute(const MysteryNode *n);
|
|
};
|
|
|
|
MysteryAttribute parse(const MysteryNode *n);
|
|
|
|
struct MultinomialAttribute : Attribute {
|
|
int sample_size_; // times to sample
|
|
float seed_; // seed for generator
|
|
explicit MultinomialAttribute(const MultinomialNode *n);
|
|
};
|
|
|
|
|
|
MultinomialAttribute parse(const MultinomialNode *n);
|
|
|
|
struct NonMaxSuppressionAttribute : Attribute {
|
|
int center_point_box_; // format of box data
|
|
explicit NonMaxSuppressionAttribute(const NonMaxSuppressionNode *n);
|
|
};
|
|
|
|
NonMaxSuppressionAttribute parse(const NonMaxSuppressionNode *n);
|
|
|
|
struct OneHotAttribute : Attribute {
|
|
int axis_; // axis on which one-hot is added
|
|
explicit OneHotAttribute(const HardmaxNode *n);
|
|
explicit OneHotAttribute(const OneHotNode *n);
|
|
};
|
|
|
|
OneHotAttribute parse(const OneHotNode *n);
|
|
using HardmaxAttribute = OneHotAttribute; HardmaxAttribute parse(const HardmaxNode *n);
|
|
|
|
struct PadAttribute : Attribute {
|
|
Shape pads_;
|
|
explicit PadAttribute(const PadNode *n);
|
|
};
|
|
|
|
PadAttribute parse(const PadNode *n);
|
|
|
|
struct PoolingAttribute : Attribute {
|
|
uint32_t top_pad_;
|
|
uint32_t bottom_pad_;
|
|
uint32_t left_pad_;
|
|
uint32_t right_pad_;
|
|
uint32_t kernel_h_;
|
|
uint32_t kernel_w_;
|
|
uint32_t stride_h_;
|
|
uint32_t stride_w_;
|
|
std::vector<int> pads_;
|
|
std::vector<int> kernels_;
|
|
std::vector<int> strides_;
|
|
explicit PoolingAttribute(const MaxPoolNode *n);
|
|
explicit PoolingAttribute(const MaxUnpoolNode *n);
|
|
};
|
|
|
|
|
|
using MaxPoolAttribute = PoolingAttribute; MaxPoolAttribute parse(const MaxPoolNode *n);
|
|
using MaxUnpoolAttribute = PoolingAttribute; MaxUnpoolAttribute parse(const MaxUnpoolNode *n);
|
|
|
|
struct AveragePoolAttribute : Attribute {
|
|
uint32_t top_pad_;
|
|
uint32_t bottom_pad_;
|
|
uint32_t left_pad_;
|
|
uint32_t right_pad_;
|
|
uint32_t kernel_h_;
|
|
uint32_t kernel_w_;
|
|
uint32_t stride_h_;
|
|
uint32_t stride_w_;
|
|
int32_t count_include_pad_; // flag to include padding
|
|
explicit AveragePoolAttribute(const AveragePoolNode *n);
|
|
};
|
|
|
|
AveragePoolAttribute parse(const AveragePoolNode *n);
|
|
|
|
struct RandomUniformLikeAttribute : Attribute {
|
|
float high_; // upper bound
|
|
float low_; // lower bound
|
|
float seed_; // seed for generator
|
|
explicit RandomUniformLikeAttribute(const RandomUniformLikeNode *n);
|
|
};
|
|
|
|
RandomUniformLikeAttribute parse(const RandomUniformLikeNode *n);
|
|
|
|
struct ReduceAttribute : Attribute {
|
|
Shape axes_; // axes to reduce on
|
|
int keepdims_; // flag to keep dimensions
|
|
int noop_with_empty_axes_; // added opset 18
|
|
explicit ReduceAttribute(const ReduceSumNode *n);
|
|
explicit ReduceAttribute(const ReduceLogSumNode *n);
|
|
explicit ReduceAttribute(const ReduceLogSumExpNode *n);
|
|
explicit ReduceAttribute(const ReduceMeanNode *n);
|
|
explicit ReduceAttribute(const ReduceMaxNode *n);
|
|
explicit ReduceAttribute(const ReduceSumSquareNode *n);
|
|
};
|
|
|
|
using ReduceSumAttribute =ReduceAttribute; ReduceSumAttribute parse(const ReduceSumNode *n);
|
|
using ReduceLogSumAttribute =ReduceAttribute; ReduceLogSumAttribute parse(const ReduceLogSumNode *n);
|
|
using ReduceLogSumExpAttribute = ReduceAttribute; ReduceLogSumExpAttribute parse(ReduceLogSumExpNode *n);
|
|
using ReduceMeanAttribute = ReduceAttribute; ReduceMeanAttribute parse(const ReduceMeanNode *n);
|
|
using ReduceMaxAttribute = ReduceAttribute; ReduceMaxAttribute parse(const ReduceMaxNode *n);
|
|
using ReduceSumSquareAttribute = ReduceAttribute; ReduceSumSquareAttribute parse(const ReduceSumAttribute *n);
|
|
|
|
struct ResizeAttribute : Attribute {
|
|
std::string coordinate_transformation_mode_;
|
|
float cubic_coeff_a_;
|
|
int exclude_outside_;
|
|
float extrapolation_value_;
|
|
std::string mode_;
|
|
std::string nearest_mode_;
|
|
explicit ResizeAttribute(const ResizeNode *n);
|
|
};
|
|
|
|
ResizeAttribute parse(const ResizeNode *n);
|
|
|
|
struct RNNAttribute : Attribute {
|
|
std::string direction_; // direction of RNN
|
|
std::vector<float> activation_alpha_; // scaling for activations
|
|
std::vector<float> activation_beta_; // scaling for activations
|
|
std::vector<std::string> activations_; // activation functions
|
|
int linear_before_reset_ = 0; // flag to apply transformation before reset
|
|
int input_forget_ = 0; // flag to couple input and forget gate
|
|
int hidden_size_; // number of hidden neurons
|
|
float clip_ = 0.0; // bounds
|
|
explicit RNNAttribute(const GRUNode *n);
|
|
explicit RNNAttribute(const LSTMNode *n);
|
|
};
|
|
|
|
using GRUAttribute = RNNAttribute; RNNAttribute parse(const GRUNode *n);
|
|
using LSTMAttribute = RNNAttribute; RNNAttribute parse(const LSTMNode *n);
|
|
|
|
struct RoiAlignAttribute : Attribute {
|
|
std::string mode_; //
|
|
std::string coordinate_transformation_mode_; //
|
|
int output_height_; // pooled output height
|
|
int output_width_; // pooled output width
|
|
int sampling_ratio_; // points in ROI to sample
|
|
float spatial_scale_; // scale of feature map to image
|
|
explicit RoiAlignAttribute(const RoiAlignNode *n);
|
|
};
|
|
|
|
RoiAlignAttribute parse(const RoiAlignNode *n);
|
|
|
|
struct SliceAttribute : Attribute {
|
|
std::vector<uint32_t> start_index_;
|
|
std::vector<uint32_t> end_index_;
|
|
std::vector<uint32_t> input_low_dim_size_;
|
|
std::vector<uint32_t> output_low_dim_size_;
|
|
std::vector<uint32_t> steps_;
|
|
explicit SliceAttribute(const SliceNode *n);
|
|
};
|
|
|
|
SliceAttribute parse(const SliceNode *n);
|
|
|
|
struct SoftmaxAttribute : Attribute {
|
|
int axis_;
|
|
explicit SoftmaxAttribute(const SoftmaxNode *n);
|
|
};
|
|
|
|
SoftmaxAttribute parse(const SoftmaxNode *n);
|
|
|
|
struct LogSoftmaxAttribute : Attribute {
|
|
int axis_;
|
|
explicit LogSoftmaxAttribute(const LogSoftmaxNode *n);
|
|
};
|
|
|
|
LogSoftmaxAttribute parse(const LogSoftmaxNode *n);
|
|
|
|
struct TransposeAttribute : Attribute {
|
|
Shape perm_; // permutation of axes
|
|
explicit TransposeAttribute(const TransposeNode *n);
|
|
};
|
|
|
|
TransposeAttribute parse(const TransposeNode *n);
|
|
|
|
|
|
|
|
|
|
struct UpsampleAttribute : Attribute {
|
|
string mode_; // permutation of axes
|
|
explicit UpsampleAttribute(const UpsampleNode *n);
|
|
};
|
|
|
|
UpsampleAttribute parse(UpsampleNode *n);
|
|
|
|
struct LoopAttribute : Attribute {
|
|
Graph body_;
|
|
explicit LoopAttribute(const LoopNode *n);
|
|
};
|
|
|
|
LoopAttribute parse(LoopNode *n);
|
|
|
|
struct SeluAttribute : Attribute {
|
|
float alpha_; // coefficient for function
|
|
float gamma_; // coefficient for function
|
|
explicit SeluAttribute(const SeluNode *n);
|
|
};
|
|
|
|
SeluAttribute parse(const SeluNode *n);
|
|
|
|
struct ShrinkAttribute : Attribute {
|
|
float bias_; // coefficient for function
|
|
float lambd_; // coefficient for function
|
|
explicit ShrinkAttribute(const ShrinkNode *n);
|
|
};
|
|
|
|
ShrinkAttribute parse(const ShrinkNode *n);
|
|
|
|
|
|
struct ReverseSequenceAttribute : Attribute {
|
|
uint32_t batch_axis_;
|
|
uint32_t time_axis_;
|
|
explicit ReverseSequenceAttribute(const ReverseSequenceNode *n);
|
|
};
|
|
|
|
ReverseSequenceAttribute parse(const ReverseSequenceNode *n);
|
|
|
|
#define CREATE_ATTRIBUTE(name) \
|
|
using name##Attribute = Attribute; \
|
|
name##Attribute inline parse(const name##Node *n) {return Attribute(n);}
|
|
|
|
CREATE_ATTRIBUTE(Add)
|
|
CREATE_ATTRIBUTE(Sub)
|
|
CREATE_ATTRIBUTE(Mul)
|
|
CREATE_ATTRIBUTE(Div)
|
|
CREATE_ATTRIBUTE(Pow)
|
|
|
|
CREATE_ATTRIBUTE(Det)
|
|
CREATE_ATTRIBUTE(Dropout)
|
|
CREATE_ATTRIBUTE(Exp)
|
|
CREATE_ATTRIBUTE(Erf)
|
|
CREATE_ATTRIBUTE(Equal)
|
|
CREATE_ATTRIBUTE(Flatten)
|
|
CREATE_ATTRIBUTE(Floor)
|
|
|
|
CREATE_ATTRIBUTE(GlobalAveragePool)
|
|
CREATE_ATTRIBUTE(GlobalMaxPool)
|
|
CREATE_ATTRIBUTE(Greater)
|
|
CREATE_ATTRIBUTE(GreaterOrEqual)
|
|
CREATE_ATTRIBUTE(Max)
|
|
CREATE_ATTRIBUTE(Mean)
|
|
CREATE_ATTRIBUTE(Mish)
|
|
CREATE_ATTRIBUTE(Mod)
|
|
CREATE_ATTRIBUTE(MatMulInteger)
|
|
CREATE_ATTRIBUTE(Neg)
|
|
CREATE_ATTRIBUTE(NonZero)
|
|
CREATE_ATTRIBUTE(Not)
|
|
|
|
CREATE_ATTRIBUTE(PRelu)
|
|
CREATE_ATTRIBUTE(Relu)
|
|
CREATE_ATTRIBUTE(Reshape)
|
|
CREATE_ATTRIBUTE(ScatterND)
|
|
CREATE_ATTRIBUTE(Sigmoid)
|
|
CREATE_ATTRIBUTE(Sqrt)
|
|
CREATE_ATTRIBUTE(KneronScale)
|
|
CREATE_ATTRIBUTE(KneronSwish)
|
|
CREATE_ATTRIBUTE(KneronHardSwish)
|
|
CREATE_ATTRIBUTE(KneronLog2)
|
|
CREATE_ATTRIBUTE(KneronLogExp)
|
|
CREATE_ATTRIBUTE(KneronPow2)
|
|
CREATE_ATTRIBUTE(KneronSquare)
|
|
CREATE_ATTRIBUTE(Squeeze)
|
|
CREATE_ATTRIBUTE(IsNaN)
|
|
CREATE_ATTRIBUTE(Less)
|
|
|
|
CREATE_ATTRIBUTE(LessOrEqual)
|
|
CREATE_ATTRIBUTE(Abs)
|
|
CREATE_ATTRIBUTE(And)
|
|
CREATE_ATTRIBUTE(Cos)
|
|
CREATE_ATTRIBUTE(Cosh)
|
|
CREATE_ATTRIBUTE(Acos)
|
|
CREATE_ATTRIBUTE(Asin)
|
|
CREATE_ATTRIBUTE(Atan)
|
|
CREATE_ATTRIBUTE(Acosh)
|
|
CREATE_ATTRIBUTE(Asinh)
|
|
CREATE_ATTRIBUTE(Atanh)
|
|
CREATE_ATTRIBUTE(BitwiseAnd)
|
|
CREATE_ATTRIBUTE(BitwiseOr)
|
|
CREATE_ATTRIBUTE(BitwiseXor)
|
|
CREATE_ATTRIBUTE(BitwiseNot)
|
|
CREATE_ATTRIBUTE(Ceil)
|
|
CREATE_ATTRIBUTE(Softplus)
|
|
CREATE_ATTRIBUTE(Softsign)
|
|
|
|
CREATE_ATTRIBUTE(Log)
|
|
|
|
|
|
CREATE_ATTRIBUTE(Tanh)
|
|
CREATE_ATTRIBUTE(Tile)
|
|
CREATE_ATTRIBUTE(Unsqueeze)
|
|
CREATE_ATTRIBUTE(Min)
|
|
CREATE_ATTRIBUTE(Or)
|
|
|
|
CREATE_ATTRIBUTE(Identity)
|
|
CREATE_ATTRIBUTE(Reciprocal)
|
|
CREATE_ATTRIBUTE(KneronInvsqrt)
|
|
}
|
|
}
|
|
|
|
#endif // PIANO_DYNASTY_INCLUDE_PARSER_ATTRIBUTEPARSER_H_
|