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;
}

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;
}

// mluOpDataType_t;
enum DataType {
  DTYPE_HALF            = 1;
  DTYPE_FLOAT           = 2;
  DTYPE_INT8            = 3;
  DTYPE_INT16           = 4;
  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;

  optional int32 position         = 5;
  optional float scale            = 6;
  optional int32 offset           = 14;

  // data
  repeated float value_f          = 7;
  repeated int32 value_i          = 8;
  repeated int64 value_l          = 17;
  repeated uint32 value_ui        = 18;
  repeated uint64 value_ul        = 19;
  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;
}

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;
}

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 string op_type                             = 8;     // add op_type for mmcv op

  // 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 AddNParam   addn_param                               = 104;    // 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 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 DynamicPointToVoxelForwardParam dynamic_point_to_voxel_forward_param = 4012;  // DynamicPointToVoxelForwardParam
}


// --------------------
// 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
}

// 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;
}

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;
}

message AddNParam {
  required int32 num = 1;
}

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

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;
}

// 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 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 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 mluOpDynamicPointToVoxelForward()
message DynamicPointToVoxelForwardParam {
   required ReduceMode reduce_type = 1;
}