mlu_op_test.proto

/*************************************************************************
 * Copyright (C) [2022] by Cambricon, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *************************************************************************/
syntax = "proto2";
package mluoptest;

// mluOpTensorLayout_t;
enum TensorLayout {
  LAYOUT_NCHW  = 1;
  LAYOUT_NHWC  = 2;
  LAYOUT_HWCN  = 3;
  LAYOUT_NDHWC = 4;
  LAYOUT_ARRAY = 5;
  LAYOUT_TNC   = 6;
  LAYOUT_NTC   = 7;
  LAYOUT_NCDHW = 8;
  LAYOUT_NC    = 9;
  LAYOUT_NLC   = 10;
  LAYOUT_NCL   = 11;
}

enum SeqDataLayout {
  SEQDATA_TNC        = 0;
  SEQDATA_TNC_PACKED = 1;
  SEQDATA_NTC        = 2;
  SEQDATA_NC         = 3;
  SEQDATA_TNBC       = 4;
  SEQDATA_TBNC       = 5;
  SEQDATA_NBTC       = 6;
  SEQDATA_NTBC       = 7;
  SEQDATA_BNTC       = 8;
  SEQDATA_BTNC       = 9;
}

// DataType_t
enum DataType {
  DTYPE_HALF  = 1;
  DTYPE_FLOAT = 2;
  DTYPE_INT8  = 3;
  DTYPE_INT16 = 4;
  DTYPE_INT31 = 5;
  DTYPE_INT32 = 6;
  DTYPE_INT64 = 16;
  DTYPE_BFLOAT16 = 7;
  DTYPE_DOUBLE   = 8;
  DTYPE_UINT8    = 9;
  DTYPE_UINT16   = 10;
  DTYPE_UINT32   = 11;
  DTYPE_UINT64   = 17;
  DTYPE_BOOL     = 12;
  DTYPE_COMPLEX64  = 13;   // deprecated, use DTYPE_COMPLEX_FLOAT instead
  DTYPE_COMPLEX128 = 14;   // deprecated, use DTYPE_COMPLEX_DOUBLE instead
  DTYPE_INVALID = 15;
  DTYPE_COMPLEX_HALF  = 18;   // complex dtype of half precision
  DTYPE_COMPLEX_FLOAT  = 19;   // complex dtype of float precision
  DTYPE_COMPLEX_DOUBLE = 20;   // complex dtype of double precision
  DTYPE_UNSET = 0;
}

enum Device {
  CPU           = 1;
  GPU           = 2;
  CMODEL        = 3;
  GENERATOR_CPU = 4;
}

enum EvaluationCriterion {
  MAPE    = 1;
  SMAPE   = 2;
  MAXAPE  = 3;
  SMAXAPE = 4;
  NRMSE   = 5;
  DIFF1   = 6;
  DIFF2   = 7;
  DIFF3   = 8;
  DIFF3_2 = 9;
  DIFF4   = 10;
  DIFF_KL = 11;
}

enum MLUPlatform {
  MLU200 = 1;
  MLU370 = 2;
  MLU590 = 4;
}

enum PointerMode {
  POINTER_MODE_HOST   = 0;
  POINTER_MODE_DEVICE = 1;
}

enum MatMulCastMode {
  MLUOP_MATMUL_OFFLINE_SYMMETRIC_QUANTIZE = 0;
  MLUOP_MATMUL_OFFLINE_ASYMMETRIC_QUANTIZE = 1;
  MLUOP_MATMUL_PARTIAL_ONLINE_QUANTIZE = 2;
  MLUOP_MATMUL_GLOBAL_ONLINE_QUANTIZE = 3;
  MLUOP_MATMUL_NO_QUANTIZE = 4;
  MLUOP_MATMUL_BYPASS_QUANTIZE = 255;
}

enum QuantizeMode {
  QUANTIZE_POSITION  = 0;
  QUANTIZE_POSITION_SCALE = 1;
  QUANTIZE_POSITION_SCALE_OFFSET = 2;
}

enum EpilogueType {
  MATMUL_EPI_NONE = 0;
  MATMUL_EPI_BIAS = 1;
  MATMUL_EPI_BIAS_SCALE_BN_ACTIVATION = 2;
}

// param to activation
enum ActivationMode{
  ACTIVATION_SIGMOID      = 0;
  ACTIVATION_RELU         = 1;
  ACTIVATION_RELU6        = 2;
  ACTIVATION_TANH         = 3;
  ACTIVATION_CLIPPED_RELU = 4;
  ACTIVATION_ELU          = 5;
  ACTIVATION_IDENTITY     = 6;
  ACTIVATION_SELU         = 7;
  ACTIVATION_GELU         = 8;
  ACTIVATION_LEAKYRELU    = 9;
  ACTIVATION_TF_LEAKYRELU = 10;
  ACTIVATION_CAFFE_RELU6  = 11;
  ACTIVATION_GLU          = 12;
  ACTIVATION_SWISH        = 13;
  ACTIVATION_SILU         = 14;
  ACTIVATION_HARDSIGMOID  = 15;
  ACTIVATION_HARDSWISH    = 16;
  ACTIVATION_ELU_V2      = 17;
  ACTIVATION_LOGSIGMOID = 18;
  ACTIVATION_HARDSHRINK = 19;
  ACTIVATION_SOFTSHRINK = 20;
}

// param to reduce
enum ReduceMode {
  REDUCE_MODE_SUM = 0;
  REDUCE_MODE_MEAN = 1;
  REDUCE_MODE_MAX = 2; 
}

message RuntimeEnvironment {
  required string dl_framework  =  1;
}

message Shape {
  repeated int32 dims       = 1;
  repeated int32 dim_stride = 2;
}

message Thresholds {
  repeated double evaluation_threshold      = 1;
  repeated double evaluation_threshold_imag = 2;
}

// mluOpTensorDescriptor_t
message Tensor {
  required string id   = 1;
  required Shape shape = 2;
  required TensorLayout layout = 3 [default = LAYOUT_ARRAY];
  required DataType dtype      = 4 [default = DTYPE_FLOAT];

  optional DataType mlu_dtype     = 12;
  optional DataType onchip_dtype  = 13 [default = DTYPE_UNSET];

  optional int32 position = 5 [default = 1000];
  optional float scale    = 6 [default = 1000.0];
  optional int32 offset   = 14 [default = 1000];

  // data
  repeated float value_f  = 7 [packed=true];
  repeated int32 value_i  = 8 [packed=true];
  repeated int64 value_l = 17 [packed=true];
  repeated uint32 value_ui = 18 [packed=true];
  repeated uint64 value_ul = 19 [packed=true];
  repeated string value_h = 9;
  // else data source
  optional string path    = 11;
  // random data = delete
  optional RandomData random_data = 10;
  // dynamic threshold
  optional Thresholds thresholds = 15;
  optional int32 threshold_use = 16;

  optional PointerMode pointer_mode = 29 [default = POINTER_MODE_DEVICE];
  // is_cpu_scalar is true when shape is (), value num is 1. redudant information for debug
  optional bool is_cpu_scalar = 30 [default = false];
}

message SeqData {
  required string id                    = 1;
  required Shape shape                  = 2;
  required TensorLayout layout          = 3 [default = LAYOUT_ARRAY];
  required DataType dtype               = 4 [default = DTYPE_FLOAT];
  optional DataType mlu_dtype           = 5;


  required int32 seq_length_array_size  = 6;
  required int32 seq_length_array       = 7;


  optional int32 position               = 8;
  optional float scale                  = 9;


  // data
  repeated float value_f                = 10;
  repeated int32 value_i                = 11;
  repeated string value_h               = 12;
  // else data source
  optional string path                  = 13;
  // random data = delete
  optional RandomData random_data       = 14;
}

enum OpType {
  ABS = 2022;
  ACTIVE_ROTATED_FILTER_FORWARD = 257073;
  ADDN = 7178;
  ADAMW = 7979;
  BALL_QUERY = 20231025;
  BATCH_MATMUL_BCAST  = 2049;
  BBOX_OVERLAPS = 2041;
  BORDER_ALIGN_BACKWARD = 9001;
  BORDER_ALIGN_FORWARD = 1009;
  BOX_IOU_ROTATED = 200;
  CARAFE_BACKWARD = 409;
  CARAFE_FORWARD = 408;
  COPY = 13;
  DEFORM_ROI_POOL_BACKWARD = 10127;
  DEFORM_ROI_POOL_FORWARD = 10126;
  DIFF_IOU_ROTATED_SORT_VERTICES_FORWARD = 402;
  DIV = 2020;
  DYNAMIC_POINT_TO_VOXEL_BACKWARD = 404;
  DYNAMIC_POINT_TO_VOXEL_FORWARD = 405;
  EXPAND = 5;
  FFT = 65536; 
  FILL = 13199;
  FOCAL_LOSS_SIGMOID_BACKWARD = 12322;
  FOCAL_LOSS_SIGMOID_FORWARD = 15000;
  GATHER_ND = 20;
  GENERATE_PROPOSALS_V2 = 701;
  GET_INDICE_PAIRS = 702;
  INDICE_CONVOLUTION_BACKWARD_DATA = 900;
  INDICE_CONVOLUTION_BACKWARD_FILTER = 901;
  INDICE_CONVOLUTION_FORWARD = 902;
  LOG = 20333;
  MASKED_COL2IM_FORWARD = 2201;
  MASKED_IM2COL_FORWARD = 2202;
  MATMUL = 536470911;
  MOE_DISPATCH_BACKWARD_DATA = 1303;
  MOE_DISPATCH_BACKWARD_GATE = 1304;
  MOE_DISPATCH_FORWARD = 1305;
  MS_DEFORM_ATTN_BACKWARD = 1013;
  MS_DEFORM_ATTN_FORWARD = 16005;
  MUTUAL_INFORMATION_BACKWARD = 1308;
  MUTUAL_INFORMATION_FORWARD = 1309;
  NMS = 768;
  NMS_ROTATED = 1401;
  OP_TENSOR = 2;
  PAD = 33;
  POINTS_IN_BOXES = 217;
  POLY_NMS = 1602;
  PRIOR_BOX = 1603;
  PSAMASK_BACKWARD = 134659;
  PSAMASK_FORWARD = 134658;
  PSROIPOOL_BACKWARD = 1606;
  PSROIPOOL_FORWARD = 1607;
  REDUCE = 1199;
  ROI_ALIGN_BACKWARD = 4427;
  ROI_ALIGN_ROTATED_BACKWARD = 134661;
  ROI_ALIGN_ROTATED_FORWARD = 134660;
  ROI_CROP_BACKWARD = 1804;
  ROI_CROP_FORWARD = 1805;
  ROI_POOLING_BACKWARD = 888888;
  ROI_POOLING_FORWARD = 210812;
  ROIALIGN_FORWARD = 1808;
  ROIAWARE_POOL3D_BACKWARD = 10121;
  ROIAWARE_POOL3D_FORWARD = 10120;
  ROIPOINT_POOL3D = 16002;
  ROTATED_FEATURE_ALIGN_BACKWARD = 20221008;
  ROTATED_FEATURE_ALIGN_FORWARD = 20229510;
  SCATTER_ND = 359;
  SQRT = 2021;
  SQRT_BACKWARD = 55660;
  STRIDED_SLICE = 657;
  SYNC_BATCH_NORM_BACKWARD_ELEMT = 1663;
  SYNC_BATCHNORM_BACKWARD_ELEMT_V2 = 1664;
  SYNC_BATCHNORM_BACKWARD_REDUCE = 38324;
  SYNC_BATCHNORM_ELEMT = 1662;
  SYNC_BATCHNORM_GATHER_STATS_WITH_COUNTS = 11113;
  SYNC_BATCHNORM_STATS = 11112;
  TENSOR_STRIDE_PROCESS = 2000;
  THREE_INTERPOLATE_BACKWARD = 2001;
  THREE_INTERPOLATE_FORWARD = 2002;
  THREE_NN_FORWARD = 2003;
  TIN_SHIFT_BACKWARD = 150003;
  TIN_SHIFT_FORWARD = 150002;
  TRANSFORM = 4;
  TRANSPOSE = 64;
  UNIQUE = 1267;
  UTILS = 2101;
  VOXEL_POOLING_FORWARD = 2200;
  VOXELIZATION = 2203;
  YOLO_BOX = 2500;
  DCN_FORWARD = 4051;
  DCN_BACKWARD_WEIGHT = 406;
  DCN_BACKWARD_DATA = 407;
}

message Node {
  optional string valid                               = 1 [default = "True"];
  optional string pattern                             = 2 [default = "random"];
  optional Device device                              = 3 [default = CPU];

  required string op_name                             = 5 [default = "unknown"];    // op_name
  repeated Tensor input                               = 6;
  repeated Tensor output                              = 7;
  optional OpType op_type                             = 8;
  optional string api_name                            = 1048576;

  // evaluation
  optional TestParam test_param                       = 10;    // remove this param later = delete
  optional double latency                             = 11;    // latency
  optional double io_efficiency                       = 12;    // efficiency
  optional double efficiency                          = 13;    // efficiency
  repeated EvaluationCriterion evaluation_criterion   = 14;
  repeated double evaluation_threshold                = 15;
  repeated double evaluation_threshold_imag           = 4832;
  optional double theory_io_size                      = 16;
  optional double theory_compute_ops                  = 17;
  optional double workspace_size                      = 18;
  repeated double threshold_rate                      = 21;   // determine the magnification of dynamic threshold
  repeated MLUPlatform supported_mlu_platform         = 22;
  optional RuntimeEnvironment runtime_env             = 37;

  optional HandleParam handle_param                   = 23451;

  extensions 3000 to 4000;

  optional ConvolutionForwardParam  convolution_forward_param  = 23;
  optional AddNParam   addn_param                               = 104;    // param
  optional AdamWParam adamw_param                               = 403505; // param
  optional TransposeParam transpose_param                       = 62;     // param
  optional ScatterNdParam scatter_nd_param                      = 117;    // param
  optional UniqueParam unique_param                             = 9111;   // param
  optional DivParam    div_param                                = 4001;   // param
  optional ReduceParam reduce_param                             = 85;     // param
  optional LogParam    log_param                                = 4002;   // param
  optional SqrtParam   sqrt_param                               = 4003;   // param
  optional PsRoiPoolForwardParam psroipool_forward_param        = 4004;   // param
  optional PsRoiPoolBackwardParam psroipool_backward_param      = 4005;   // param
  optional PriorBoxParam prior_box_param                        = 4006;   // PriorBoxParam
  optional PolyNmsParam poly_nms_param                          = 4010;   // PolyNmsParam
  optional GenerateProposalsV2Param generate_proposals_v2_param = 5930;   // GenerateProposalsV2Param
  optional YoloBoxParam yolo_box_param                          = 4011;   // YoloBoxParam
  optional VoxelPoolingForwardParam voxel_pooling_forward_param = 4009;   // VoxelPoolingForwardParam
  optional BoxIouRotatedParam box_iou_rotated_param             = 200;   // BoxIouRotatedParam
  optional NmsRotatedParam nms_rotated_param                    = 201;   // NmsRotatedParam
  optional RoialignParam roialign_param                         = 202;  // RoiAlignForwardParam
  optional BboxOverlapsParam bbox_overlaps_param                = 2041;  // BboxOverlapsParam
  optional BallQueryParam  ball_query_param                     = 4008;  // param
  optional FillParam       fill_param                           = 13199;  // param
  optional GetIndicePairsParam get_indice_pairs_param           = 202302031;  // param
  optional MoeDispatchBackwardDataParam moe_dispatch_backward_data_param = 20230216; // param
  optional RoiawarePool3dForwardParam  roiaware_pool3d_forward_param     = 10120;  // param
  optional RoiawarePool3dBackwardParam  roiaware_pool3d_backward_param   = 10121;  // param
  optional RoiPointPool3dParam roipoint_pool3d_param            = 16002; // param
  optional NmsParam nms_param                                   = 768; // param
  optional PsamaskForwardParam psamask_forward_param            = 134658;  // PsamaskForwardParam
  optional PsamaskBackwardParam psamask_backward_param          = 134659;  // PsamaskBackwardParam
  optional VoxelizationParam  voxelization_param                = 6564;  // Voxelizationparam
  optional RoiAlignRotatedForwardParam roi_align_rotated_forward_param   = 134660;  //param
  optional RoiAlignRotatedBackwardParam roi_align_rotated_backward_param = 134661;  // param
  optional RotatedFeatureAlignForwardParam rotated_feature_align_forward_param   = 20229510;  //param
  optional RotatedFeatureAlignBackwardParam rotated_feature_align_backward_param = 20221008;  //param
  optional FocalLossSigmoidForwardParam focal_loss_sigmoid_forward_param   = 15000; // param
  optional FocalLossSigmoidBackwardParam focal_loss_sigmoid_backward_param = 12322; // param
  optional DeformRoiPoolForwardParam deform_roi_pool_forward_param   = 10126;  //param
  optional DeformRoiPoolBackwardParam deform_roi_pool_backward_param = 10127;  //param
  optional IndiceConvolutionBackwardDataParam indice_convolution_backward_data_param = 22120599;  // param
  optional IndiceConvolutionBackwardParam indice_convolution_backward_param = 20230131;  //param
  optional IndiceConvolutionForwardParam indice_convolution_forward_param = 23020721;  //param
  optional CarafeParam  carafe_param     = 408;  // CarafeForwardParam and CarafeBackwardParam
  optional MoeDispatchForwardParam moe_dispatch_forward_param = 23333;  // param
  optional MoeDispatchBackwardGateParam  moe_dispatch_backward_gate_param   = 135246;  // param
  optional MatMulParam            matmul_param                  = 93;   // MatMulParam
  optional PadParam               pad_param                     = 94;   //  PadParam
  optional RoiAlignBackwardParam roi_align_backward_param       = 4427;  // RoiAlignBackwardParam
  optional MsDeformAttnForwardParam ms_deform_attn_forward_param = 16005; // MsDeformAttnForwardParam
  optional MsDeformAttnBackwardParam ms_deform_attn_backward_param = 1006;  // MsDeformAttnBackwardParam
  optional MutualInformationBackwardParam mutual_information_backward_param = 20230414; // MutualInformationBackwardParam
  optional BorderAlignParam border_align_param = 9001;  // BorderAlignForwardParam and BorderAlignBackwardParam
  optional DynamicPointToVoxelForwardParam dynamic_point_to_voxel_forward_param = 4012;  // DynamicPointToVoxelForwardParam
  optional DynamicPointToVoxelBackwardParam dynamic_point_to_voxel_backward_param = 4013;  // DynamicPointToVoxelBackwardParam
  optional MaskedIm2colForwardParam masked_im2col_forward_param = 2201;  // MaskedIm2colForwardParam
  optional RoiPoolingForwardParam roi_pooling_forward_param = 210812;  // RoiPoolingForwardParam
  optional RoiPoolingBackwardParam roi_pooling_backward_param = 888888;  // RoiPoolingBackwardParam
  optional TransformParam  transform_param = 25; //TransformParam
  optional SyncBatchNormParam sync_batchnorm_stats_param = 11112;  // param
  optional SyncBatchNormParam sync_batchnorm_gather_stats_with_counts_param = 11113;  // param
  optional SyncBatchNormBackwardParam sync_batchnorm_backward_reduce_param = 38324;  // param
  optional StridedSliceParam  strided_slice_param = 44;  // param
  optional ConcatParam        concat_param = 54;         // param 
  optional OpTensorParam      op_tensor_param = 101;     // OpTensorParam
  optional BatchMatMulBCastParam batch_matmul_bcast_param       = 132;   // param
  optional FFTParam fft_param = 65536; // param
  optional DCNParam dcn_param       = 405;
}


// --------------------
// OP PARAMS
// --------------------

// random data
enum RandomDistribution {
  UNIFORM           = 1;
  GAUSSIAN          = 2;
  SAMPLE            = 3;
  BINOMIAL          = 4;
  DISCRETE_UNIFORM  = 5;
  CERTAIN           = 6;
  UNIQUE_INDEX      = 7;
}

message RandomData {
  optional int32 seed                      = 1;
  // only for uniform
  optional float lower_bound               = 2 [default = -1.0];
  optional float upper_bound               = 3 [default = 1.0];
  optional double lower_bound_double       = 8 [default = -1.0];
  optional double upper_bound_double       = 9 [default = 1.0];

  // only for gaussian
  optional float mu                        = 6 [default = 0.0];
  optional float sigma                     = 7 [default = 1.0];
  optional double mu_double                = 10 [default = 0.0];
  optional double sigma_double             = 11 [default = 1.0];

  //only for certain
  optional int32 true_number               = 12 [default = 0];
  //only for unique and sorted_unique
  optional int32 begin_index               = 13 [default = 0];
  optional int32 end_index                 = 14 [default = 0];
  optional int32 dim_shape                 = 15 [default = 1];
  optional float negative_ratio            = 16 [default = 0];
  optional int32 sorted_status             = 17 [default = 0];

  optional RandomDistribution distribution = 4 [default = UNIFORM];
  optional bool convert_dtype = 5 [default = false];  // convert float to int
}

// param of AdamW
message AdamWParam {
  required float lr    = 1 [default = 0.01];
  required float beta1 = 2 [default = 0.4];
  required float beta2 = 3 [default = 0.4];
  required float bias1 = 4 [default = 0.6];
  required float bias2 = 5 [default = 0.6];
  required float epsilon = 6 [default = 0.1];
  required float weight_decay = 7 [default = 0];
  required float scale = 8 [default = 1];
  optional bool use_nesterov = 9 [default = false];
}


// remove this param later
message TestParam {
  repeated EvaluationCriterion error_func = 1;
  repeated double error_threshold         = 2;
  repeated double error_threshold_imag    = 3;

  optional double latency                 = 5;    //   latency
  optional double efficiency              = 6;    //   efficiency
  optional Device baseline_device         = 7;
}

enum ComputationPreference {
  COMPUTATION_FAST                = 0;
  COMPUTATION_HIGH_PRECISION      = 1;
  COMPUTATION_ULTRAHIGH_PRECISION = 2;
}

// param to call mluopSetQuantizeRoundMode()/mluopGetQuantizeRoundMode()
enum QuantizeRoundMode {
  ROUND_TO_EVEN = 0;
  ROUND_HALF_UP = 1;
  ROUND_OFF_ZERO = 2;
}

// some params for handle
message HandleParam {
  optional QuantizeRoundMode round_mode = 1 [default = ROUND_OFF_ZERO];
}

enum mluOpLogBase {
  MLUOP_LOG_E  = 0; /**< base is e*/
  MLUOP_LOG_2  = 1; /**< base is 2*/
  MLUOP_LOG_10 = 2; /**< base is 10*/
}

enum ReduceTensorOp{
  REDUCE_TENSOR_ADD = 0;
  REDUCE_TENSOR_AVG = 1;
  REDUCE_TENSOR_MUL = 2;
  REDUCE_TENSOR_MAX = 3;
  REDUCE_TENSOR_MIN = 4;
  REDUCE_TENSOR_AND = 5;
  REDUCE_TENSOR_OR = 6;
  REDUCE_TENSOR_NORM1 = 7;
  REDUCE_TENSOR_NORM2 = 8;
  REDUCE_TENSOR_MAX_LAST_INDEX = 9;
  REDUCE_TENSOR_MIN_LAST_INDEX = 10;
  REDUCE_TENSOR_NORMP = 11;
  REDUCE_TENSOR_ASUM = 12;
  REDUCE_TENSOR_SUMSQ = 13;
}

enum ReduceTensorIndices{
  REDUCE_TENSOR_NO_INDICES        = 0;
  REDUCE_TENSOR_FLATTENED_INDICES = 1;
  REDUCE_TENSOR_ONLY_INDICES      = 2;
}

enum NanPropagation {
  NOT_PROPAGATE_NAN = 0;
  PROPAGATE_NAN     = 1;
}

enum IndicesType{
  BIT32_INDICES = 0;
  BIT16_INDICES = 1;
}

enum OpTensorDesc {
  OP_TENSOR_ADD = 1;
  OP_TENSOR_SUB = 2;
  OP_TENSOR_MUL = 3;
}

message ReduceParam {
  optional int32 axis          = 1 [default = 0];
  required ReduceTensorOp mode = 2 [default = REDUCE_TENSOR_MUL];
  optional ReduceTensorIndices is_indices = 3 [default = REDUCE_TENSOR_NO_INDICES];
  optional IndicesType indices_type       = 4 [default = BIT32_INDICES];
  repeated int32 axises                   = 5;
  optional DataType compute_dtype         = 6 [default = DTYPE_FLOAT];
  optional bool keep_dims = 7 [default = false];
  optional float p = 8 [default = 1.0];
  optional float alpha = 9 [default = 1.0];
  optional float beta = 10 [default = 0.0];
  optional NanPropagation nan_prop = 11 [default = NOT_PROPAGATE_NAN];
}

enum ScatterNdMode {
  SCATTERND_ADD = 0;
  SCATTERND_SUB = 1;
  SCATTERND_MUL = 2;
  SCATTERND_UPDATE = 3;
}

enum ConvolutionForwardAlgo {
  CONVOLUTION_FWD_ALGO_DIRECT   = 1;
  CONVOLUTION_FWD_ALGO_WINOGRAD = 2;
  CONVOLUTION_FWD_ALGO_GEMM     = 3;
}

enum ReorderType {
  MLUOP_REORDER = 0;
  MLUOP_NO_REORDER = 1;
}

// param to call ConvolutionForward()
message ConvolutionForwardParam {
  required int32 dimnb     = 1;
  repeated int32 pad       = 2;
  repeated int32 stride    = 3;
  repeated int32 dilation  = 4;
  optional int32 group_count  = 5 [default = 1];
  // optional ConvolutionFwdPreference preference = 5 [default = CONVOLUTION_FWD_FASTEST];
  optional ConvolutionForwardAlgo algo = 6 [default = CONVOLUTION_FWD_ALGO_DIRECT];
  optional DataType compute_type  = 7;
  optional ConvolutionCastMode cast_mode = 8 [default = MLUOP_OFFLINE_SYMMETRIC_QUANTIZE];
  optional ReorderType filter_reorder_type = 9 [default = MLUOP_NO_REORDER];
  optional ReorderType bias_reorder_type = 10 [default = MLUOP_NO_REORDER];
  // version used by gtest to choose different conv entry interface
  // version 0: keep old way to choose entry interface
  // version 1: choose ConvolutionForward
  // version 2: choose ConvolutionForwardInference
  // version 3: choose QuanztizeConvolutionForward
  optional int32 version = 11 [default = 0];
  optional int32 allow_tf32 = 12 [default = 0];
  // optional ConvolutionForwardSearchMode search_mode = 13 [default = NO_SEARCH];
  optional int32 algo_id = 14 [default = 0];
}

message AddNParam {
  required int32 num = 1;
}

message TransposeParam {
  required int32 dim     = 1;
  repeated int32 permute = 2;
}

message BorderAlignParam {
  optional int32 pool_size = 1[default = 10];
}

message ScatterNdParam {
  optional int32 version = 1 [default = 1];
  optional ScatterNdMode mode = 2 [default = SCATTERND_ADD];
}

enum UniqueSort {
  UNIQUE_UNSORT_FORWARD = 0;
  UNIQUE_SORT_ASCEND = 1;
  UNIQUE_UNSORT_REVERSE = 2;
}

message UniqueParam {
  required UniqueSort mode = 1 [default = UNIQUE_UNSORT_FORWARD];
  optional int32 dim = 2 [default = 0];
  optional bool return_inverse = 3 [default = false];
  optional bool return_counts = 4 [default = false];
  optional int32 version = 5 [default = 1];
}

// param to call mluOpLog()
message LogParam {
  required mluOpLogBase log_base        = 1 [default = MLUOP_LOG_E];
  optional ComputationPreference prefer = 2 [default = COMPUTATION_HIGH_PRECISION];
}

// param to call mluOpNms()
message NmsParam{
  required int32 run_mode = 1 [default = 0];
  optional int32 max_output_boxes = 2 [default = 100];
  optional float iou_threshold = 3 [default = 0.45];
  optional float confidence_threshold = 4 [default = 0.0];
  optional NmsInputLayout input_layout = 5 [default = NMS_INPUT_LAYOUT_NUM_ATTR];
  optional NmsOutputMode mode = 6 [default = NMS_INDICES];
  optional bool is_use_v2_api = 7 [default = false];
  optional NmsAlgo algo = 8 [default = NMS_ALGO_EXCLUDE_BOUNDARY];
  optional float offset = 9 [default = 0.0];
  optional NmsMethodMode method_mode = 10 [default = NMS_HARD_NMS];
  optional NmsBoxMode box_mode = 11 [default = NMS_BOX_DIAGONAL];
  optional float soft_nms_sigma = 12 [default = 0.0];
  optional bool pad_to_max_output_size = 13 [default = false];
}

enum NmsBoxMode {
  NMS_BOX_DIAGONAL = 0;
  NMS_BOX_CENTER = 1;
}

enum NmsInputLayout {
  NMS_INPUT_LAYOUT_NUM_ATTR = 0;
  NMS_INPUT_LAYOUT_ATTR_NUM = 1;
}

enum NmsOutputMode {
  NMS_INDICES = 0;
  NMS_CONFIDENCE_AND_POS_1 = 1;
  NMS_CONFIDENCE_AND_POS_2 = 2;
  NMS_BATCH_AND_CLASS = 3;
}

enum NmsMethodMode {
  NMS_HARD_NMS = 0;
  NMS_SOFT_NMS_LINEAR = 1;
  NMS_SOFT_NMS_GAUSSIAN = 2;
}

enum NmsAlgo {
  NMS_ALGO_EXCLUDE_BOUNDARY = 0;
  NMS_ALGO_INCLUDE_BOUNDARY = 1;
}

enum LossReduction {
  LOSS_REDUCTION_NONE = 0;
  LOSS_REDUCTION_SUM = 1;
  LOSS_REDUCTION_MEAN = 2;
}

enum ConvolutionCastMode {
  MLUOP_OFFLINE_SYMMETRIC_QUANTIZE = 0;
  MLUOP_OFFLINE_QUANTIZE_BY_CHANNEL = 1;
  MLUOP_OFFLINE_ASYMMETRIC_QUANTIZE = 2;
  MLUOP_PARTIAL_ONLINE_QUANTIZE = 3;
  MLUOP_GLOBAL_ONLINE_QUANTIZE = 4;
  MLUOP_NO_QUANTIZE = 255;
}

// param to call mluOpSqrt()
message SqrtParam {
  optional ComputationPreference prefer = 1 [default = COMPUTATION_HIGH_PRECISION];
}

message DivParam {
  optional ComputationPreference prefer = 1 [default = COMPUTATION_HIGH_PRECISION];
}

// param to call mluOpGenerateProposalsV2()
message GenerateProposalsV2Param {
  optional int32 pre_nms_top_n = 1 [default = 6000];
  optional int32 post_nms_top_n = 2 [default = 2000];
  optional float nms_thresh = 3 [default = 0.5];
  optional float min_size = 4 [default = 0.1];
  optional float eta = 5 [default = 1.0];
  optional bool pixel_offset = 6 [default = true];
}

// param to call mluOpPsRoiPoolForward()
message PsRoiPoolForwardParam{
  optional float spatial_scale = 1 [default = 0.0625];
  optional int32 group_size = 2 [default = 7];
  optional int32 output_dim = 3 [default = 8];
  optional int32 pooled_height = 4 [default = 7];
  optional int32 pooled_width = 5 [default = 7];
}

// param to call mluOpGetIndicePairs()
message GetIndicePairsParam{
  required int32 dimnb = 1;
  required int32 batch = 2;
  repeated int32 pad = 3;
  repeated int32 stride = 4;
  repeated int32 dilation = 5;
  repeated int32 input_space = 6;
  repeated int32 filter_space = 7;
  repeated int32 output_space = 8;
  optional int32 sub_m = 9 [default = 0];
  optional int32 transpose = 10 [default = 0];
  optional int32 inverse = 11 [default = 0];
  optional int32 num_act_out = 12 [default = 0];
}

// param to call mluOpPsRoiPoolbackward()
message PsRoiPoolBackwardParam{
  optional int32 output_dim = 1 [default = 8];
  optional int32 pooled_height = 2 [default = 7];
  optional int32 pooled_width = 3 [default = 7];
  optional float spatial_scale = 4 [default = 0.0625];
}

// param to call mluOpPolyNms()
message PolyNmsParam {
  required float iou_threshold = 1 [default = 0.2];
}

// param to call mluOpPriorBox()
message PriorBoxParam {
  required int32 height                     = 1 [default = 1];
  required int32 width                      = 2 [default = 1];
  required int32 im_height                  = 3 [default = 300];
  required int32 im_width                   = 4 [default = 300];
  required bool flip                        = 5 [default = true];
  required bool clip                        = 6 [default = true];
  required float step_w                     = 7 [default = 0.0];
  required float step_h                     = 8 [default = 0.0];
  required float offset                     = 9 [default = 0.5];
  required bool min_max_aspect_ratios_order = 10 [default = true];
}

// param to call mluOpSyncBatchNormStats, mluOpSyncBatchNormGatherStatsWithCounts
// and mluOpSyncBatchNormElemt.
message SyncBatchNormParam {
  required float eps = 1;
  optional float momentum = 2 [default = 0.1];
}

// param to call mluOpSyncBatchNormBackwardReduce()
message SyncBatchNormBackwardParam {
  required bool needs_input_grad0 = 1 [default = true];
  required bool needs_input_grad1 = 2 [default = true];
  required bool needs_input_grad2 = 3 [default = true];
}

// param to call mluOpVoxelPoolingForward()
message VoxelPoolingForwardParam {
  optional int32 batch_size   = 1;
  optional int32 num_points   = 2;
  optional int32 num_channels = 3;
  optional int32 num_voxel_x  = 4;
  optional int32 num_voxel_y  = 5;
  optional int32 num_voxel_z  = 6;
}

// param to call mluOpFocalLossSigmoidForward()
message FocalLossSigmoidForwardParam {
  optional ComputationPreference prefer = 999 [default = COMPUTATION_HIGH_PRECISION];
  required LossReduction reduction = 1 [default = LOSS_REDUCTION_NONE];
  required float alpha = 2 [default = 0.25];
  required float gamma = 3 [default = 2];
}

message FocalLossSigmoidBackwardParam {
  optional ComputationPreference prefer = 1 [default = COMPUTATION_HIGH_PRECISION];
  required LossReduction reduction = 2 [default = LOSS_REDUCTION_NONE];
  required float alpha = 3 [default = 0.25];
  required float gamma = 4 [default = 2];
}

// param to call mluOpBoxIouRotated()
message BoxIouRotatedParam {
  optional int32 mode   = 1 [default = 0];  // 0 is IOU, 1 is IOF
  optional bool aligned = 2 [default = false];
}

message NmsRotatedParam {
  optional float iou_threshold   = 1 [default = 0.5];
}

// param to call mluOpRoiAlignForward()
message RoialignParam{
  required int32 pooled_height = 1 [default = 7];
  required int32 pooled_width = 2 [default = 7];
  required int32 sampling_ratio = 3 [default = 2];
  required float spatial_scale = 4 [default = 0.25];
  required bool aligned = 5 [default = false];
  optional int32 pool_mode = 6 [default = 1];
  optional int32 version = 7 [default = 0];
}

// param to call mluOpBboxOverlaps()
message BboxOverlapsParam {
  optional int32 mode = 1 [default = 0];
  optional bool aligned = 2 [default = false];
  optional int32 offset = 3 [default = 0];
}

// param to call mluOpYoloBox()
message YoloBoxParam {
  optional int32 class_num        = 1 [default = 1];
  optional float conf_thresh      = 2 [default = 0.01];
  optional int32 downsample_ratio = 3 [default = 8];
  optional bool clip_bbox         = 4 [default = true];
  optional float scale_x_y        = 5 [default = 1.0];
  optional bool iou_aware         = 6 [default = true];
  optional float iou_aware_factor = 7 [default = 0.5];
}

// param to call mluOpBallQuery()
message BallQueryParam  {
  optional float min_radius = 1 [default = 0.0];
  optional float max_radius = 2 [default = 1.0];
  optional int32   nsample  = 3 [default = 1];
}

// param to call mluOpFill()
message FillParam  {
  optional float value = 1        [default = 0.0];
  optional int32 version = 2      [default = 1];
  optional PointerMode mode = 3   [default = POINTER_MODE_HOST];
  optional string   value_hex = 4 [default = "0X00000000"];
}

// param to call mluOpMoeDispatchBackwardData()
message MoeDispatchBackwardDataParam {
  optional int32 samples = 1;
  optional int32 capacity = 2;
  optional int32 hidden = 3;
  optional int32 num_experts = 4;
}

// param to call mluOpRoiawarePool3dForward()
message RoiawarePool3dForwardParam {
  optional int32 pool_method = 1 [default = 0];
  optional int32 boxes_num = 2;
  optional int32 pts_num = 3;
  optional int32 channels = 4;
  optional int32 max_pts_each_voxel = 5 [default = 128];
  optional int32 out_x = 6;
  optional int32 out_y = 7;
  optional int32 out_z = 8;
}

// param to call mluOpRoiawarePool3dBackward()
message RoiawarePool3dBackwardParam {
  optional int32 pool_method = 1 [default = 0];
  optional int32 boxes_num = 2;
  optional int32 out_x = 3;
  optional int32 out_y = 4;
  optional int32 out_z = 5;
  optional int32 channels = 6;
  optional int32 max_pts_each_voxel = 7 [default = 128];
}

// param to call mluOpRoiPointPool3d()
message RoiPointPool3dParam {
  optional int32 num_sampled_points = 1 [default = 512];
}

// param to call mluOpPsamaskForward()
message PsamaskForwardParam {
  required int32 h_mask = 1;
  required int32 w_mask = 2;
  required int32 psa_type = 3;
}

// param to call mluOpPsamaskBackward()
message PsamaskBackwardParam {
  required int32 h_mask = 1;
  required int32 w_mask = 2;
  required int32 psa_type = 3;
}

// param to call mluOpVoxelization()
message VoxelizationParam {
  optional int32 max_points   = 1 [default = 35];
  optional int32 max_voxels   = 2 [default = 20000];
  optional int32 ndim         = 3 [default = 3];
  optional bool deterministic = 4 [default = true];
}

// param to call mluOpRoiAlignRotatedForward()
message RoiAlignRotatedForwardParam {
  required int32 pooled_height  = 1;
  required int32 pooled_width   = 2;
  optional int32 sample_ratio   = 3 [default = 0];
  required float spatial_scale  = 4;
  optional bool aligned         = 5 [default = true];
  optional bool clockwise       = 6 [default = false];
}

// param to call mluOpRoiAlignRotatedBackward()
message RoiAlignRotatedBackwardParam {
  required int32 pooled_height  = 1;
  required int32 pooled_width   = 2;
  optional int32 sample_ratio   = 3 [default = 0];
  required float spatial_scale  = 4;
  optional bool aligned         = 5 [default = true];
  optional bool clockwise       = 6 [default = false];
}

// param to call mluOpRotatedFeatureAlignForward()
message RotatedFeatureAlignForwardParam {
  required float spatial_scale = 1 [default = 1.0];
  required int32 points = 2 [default = 1];
}

// param to call mluOpPad()
message PadParam{
  optional float padding_value = 1 [default = 0];
  repeated int32 padding_param = 2;
  optional bytes padding_value_hex = 3 [default = "0x00000000"];
}

// param to call mluOpRotatedFeatureAlignBackward()
message RotatedFeatureAlignBackwardParam {
  required float spatial_scale = 1 [default = 1.0];
  required int32 points = 2 [default = 1];
}

// param to call mluOpDeformRoiPoolForward()
message DeformRoiPoolForwardParam{
  required int32 sampling_ratio = 1 [default = 0];
  required float spatial_scale = 2 [default = 1.0];
  required float gamma = 3 [default = 0.1];
  required int32 pooled_height = 4 [default = 7];
  required int32 pooled_width = 5 [default = 7];
}

// param to call mluOpDeformRoiPoolBackward()
message DeformRoiPoolBackwardParam{
  required int32 sampling_ratio = 1 [default = 0];
  required float spatial_scale = 2 [default = 1.0];
  required float gamma = 3 [default = 0.1];
  required int32 pooled_height = 4 [default = 7];
  required int32 pooled_width = 5 [default = 7];
}

// param to call mluOpIndiceConvolutionBackwardData()
message IndiceConvolutionBackwardDataParam {
  optional int64 inverse = 1 [default = 0];
  optional int64 sub_m = 2 [default = 0];
  repeated int64 indice_num = 3;
}

// param to call indice mluOpIndiceConvolutionBackwardFilter
message IndiceConvolutionBackwardParam{
  optional int64 inverse     = 1 [default = 0];
  optional int64 sub_m       = 2 [default = 0];
  repeated int64 indice_num  = 3;
}

// param to call mluOpIndiceConvolutionForward()
message IndiceConvolutionForwardParam {
  required int64 num_active_out = 1;
  optional int64 inverse = 2 [default = 0];
  optional int64 sub_m = 3 [default = 0];
  repeated int64 indice_num = 4;
}

// param to call mluOpCarafeForward() and mluOpCarafeBackward()
message CarafeParam {
  optional int32 dimnb        = 1;
  optional int32 kernel_size  = 2;
  optional int32 group_size   = 3;
  optional int32 scale_factor = 4;
}

// param to call mluOpMoeDispatchForward()
message MoeDispatchForwardParam {
  optional int32 samples     = 1;
  optional int32 capacity    = 2;
  optional int32 hidden      = 3;
  optional int32 num_experts = 4;
}

// param to call mluOpMoeDispatchBackwardGate()
message MoeDispatchBackwardGateParam {
  optional int32 samples     = 1;
  optional int32 capacity    = 2;
  optional int32 hidden      = 3;
  optional int32 num_experts = 4;
}

// param to call mluOpMatMul()
message MatMulParam {
  optional bool is_trans_a = 1 [default = false];
  optional bool is_trans_b = 2 [default = false];
  optional bool has_bias = 3 [default = false];
  optional DataType compute_type = 4 [default = DTYPE_FLOAT];
  optional QuantizeMode quant_mode = 5 [default = QUANTIZE_POSITION_SCALE];
  optional bool use_beta = 6 [default = false];
  optional float alpha = 7 [default = 1.0];
  optional float beta = 8 [default = 0.0];
  optional EpilogueType epi_type = 9 [default = MATMUL_EPI_NONE];
  optional int32 inference_version = 10 [default = 1];
  optional int32 allow_tf32 = 11 [default = 0];
  optional bool has_activation = 12 [default = false];
  optional ActivationMode activation_mode = 13 [default = ACTIVATION_RELU];
  optional bool has_scale_alpha = 14 [default = false];
  optional bool has_scale_beta = 15 [default = false];
  optional bool use_alpha_beta = 16 [default = false];
  optional int32 generator_version = 17 [default = 1];
  optional MatMulCastMode cast_mode = 18 [default = MLUOP_MATMUL_BYPASS_QUANTIZE];
  optional bool atomics_allowed = 19 [default = false];
}

// param to call mluOpRoiAlignBackward()
message RoiAlignBackwardParam {
  optional float spatial_scale = 1 [default = 1.0];
  optional int32 sampling_ratio = 2 [default = 2];
  optional bool aligned = 3 [default = false];
  optional int32 pool_mode = 4 [default = 1];
  optional int32 version = 5 [default = 0];
}

// param to call mluOpMsDeformAttnForward()
message MsDeformAttnForwardParam {
  optional int32 im2col_step = 1 [default = 64];
}

// param to call mluOpMsDeformAttnBackward()
message MsDeformAttnBackwardParam {
  optional int32 im2col_step = 1 [default = 64];
}

// param to call MutualInformationBackward()
message MutualInformationBackwardParam {
  required bool overwrite_ans_grad = 1;
}

// param to call mluOpDynamicPointToVoxelForward()
message DynamicPointToVoxelForwardParam {
  required ReduceMode reduce_type = 1;
}

// param to call mluOpDynamicPointToVoxelBackward()
message DynamicPointToVoxelBackwardParam {
  required ReduceMode reduce_type = 1;
}

// param to call mluOpMaskedIm2colForward()
message MaskedIm2colForwardParam {
  optional int32 kernel_h = 1 [default = 3];
  optional int32 kernel_w = 2 [default = 3];
  optional int32 pad_h = 3 [default = 1];
  optional int32 pad_w = 4 [default = 1];
}

enum PoolingForwardMode {
  POOLING_MAX = 0;
  POOLING_AVERAGE_COUNT_INCLUDE_PADDING = 1;
  POOLING_AVERAGE_COUNT_EXCLUDE_PADDING = 2;
  POOLING_FIXED = 3;
}

// param to call cnnlExecFFT()
message FFTParam { 
  optional int32 rank = 1 [default = 1]; 
  repeated int32 n = 2; 
  optional int32 direction = 3 [default = 0]; 
  optional float scale_factor = 4 [default = 1.0]; 
} 

// param to call mluOpRoiPoolingForward()
message RoiPoolingForwardParam {
  optional float spatial_scale = 1 [default = 1];
  optional PoolingForwardMode mode = 2 [default = POOLING_MAX];
}

// param to call mluOpRoiPoolingBackward()
message RoiPoolingBackwardParam {
  optional float spatial_scale = 1 [default = 1];
  optional PoolingForwardMode mode = 2 [default = POOLING_MAX];
}

//param to call mluOpTransform()
message TransformParam{
  optional float alpha = 1 [default = 1];
  optional float beta = 2 [default = 1];
  optional float alpha_imag = 3 [default = 1];
  optional float beta_imag = 4 [default = 1];
}

// param to call mluOpStridedSlice()
message StridedSliceParam {
  repeated int32 begin = 1;
  repeated int32 end = 2;
  repeated int32 stride = 3;
}

// param to call mluOpConcat()
message ConcatParam {
  required int32 axis = 1 [default = 0];
}

// param to call mluOpOpTensor()
message OpTensorParam {
  optional float alpha1 = 1 [default = 1];
  optional float alpha2 = 2 [default = 1];
  optional float beta = 3 [default = 1];
  optional OpTensorDesc op = 4 [default = OP_TENSOR_ADD];
  optional bool input_same_addr = 5 [default = false];
}

// param to call mluOpBatchMatMulBCast() and mluOpQuantizeBatchMatMulBCast()
message BatchMatMulBCastParam {
  optional bool is_transa = 1 [default = false];
  optional bool is_transb = 2 [default = true];
  optional DataType compute_type = 3 [default = DTYPE_FLOAT];
  optional QuantizeMode quant_mode = 4 [default = QUANTIZE_POSITION_SCALE];
  optional int32 allow_tf32 = 5 [default = 0];
  optional float alpha = 6 [default = 1.0];
  optional float beta = 7 [default = 0.0];
  optional MatMulCastMode cast_mode = 8 [default = MLUOP_MATMUL_BYPASS_QUANTIZE];
  optional bool use_stride = 9 [default = false];
}

message DCNParam {
  required int32 dimnb = 1;
  repeated int32 pad = 2;
  repeated int32 stride = 3;
  repeated int32 dilation = 4;
  optional int32 deformable_group = 5 [default = 1];
  optional int32 conv_group = 6 [default = 1];
  optional int32 im2col_step = 7;
  optional DataType compute_type = 8;
}