!13081 add debug option in infer

From: @zhaodezan
Reviewed-by: @jpc_chenjianping,@zhanghaibo5
Signed-off-by: @jpc_chenjianping

mindspore/lite/nnacl/infer/adam_infer.c

@@ -17,13 +17,12 @@
 
 int AdamInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
-  int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
+#ifdef Debug
+  int check_ret = CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 10);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
-  if (10 != inputs_size) {
-    return NNACL_ERR;
-  }
+#endif
 
   if (GetElementNum(inputs[0]) != GetElementNum(inputs[1]) || GetElementNum(inputs[0]) != GetElementNum(inputs[2]) ||
       GetElementNum(inputs[0]) != GetElementNum(inputs[9]) || GetElementNum(inputs[3]) != 1 ||

mindspore/lite/nnacl/infer/add_sub_grad_infer.c

@@ -19,10 +19,13 @@
 
 int AddSubGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                          OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 3, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *dy = inputs[0];
   const TensorC *x1 = inputs[1];
   const TensorC *x2 = inputs[2];

mindspore/lite/nnacl/infer/addn_infer.c

@@ -18,10 +18,13 @@
 
 int AddnInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
-  if (check_ret == NNACL_NULL_PTR) {
-    return NNACL_NULL_PTR;
+  if (check_ret != NNACL_OK) {
+    return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   if (inputs_size < 2) {

mindspore/lite/nnacl/infer/apply_momentum_infer.c

@@ -18,13 +18,12 @@
 
 int ApplyMomentumInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                             OpParameter *parameter) {
-  int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
+#ifdef Debug
+  int check_ret = CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 5);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
-  if (inputs_size != 5) {
-    return NNACL_INPUT_TENSOR_ERROR;
-  }
+#endif
 
   if (GetElementNum(inputs[0]) != GetElementNum(inputs[1]) || GetElementNum(inputs[0]) != GetElementNum(inputs[3]) ||
       GetElementNum(inputs[2]) != 1 || GetElementNum(inputs[4]) != 1) {

mindspore/lite/nnacl/infer/argmin_max_infer.c

@@ -18,11 +18,16 @@
 
 int ArgMinMaxInferShape(const TensorC *const *inputs, const size_t inputs_size, TensorC **outputs,
                         const size_t outputs_size, OpParameter *parameter) {
-  int check_ret_1 = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
-  int check_ret_2 = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 2);
-  if (check_ret_1 != NNACL_OK && check_ret_2 != NNACL_OK) {
+#ifdef Debug
+  int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
+  if (check_ret != NNACL_OK) {
+    return check_ret;
+  }
+  if (inputs_size != 1 || outputs_size > 2) {
     return NNACL_ERR;
   }
+#endif
+
   ArgMinMaxParameter *param = (ArgMinMaxParameter *)parameter;
   const TensorC *input = inputs[0];
   TensorC *output_1 = NULL;

mindspore/lite/nnacl/infer/arithmetic_grad_infer.c

@@ -25,10 +25,13 @@
  * */
 int ArithmeticGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                              OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 3, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *dy = inputs[0];
   const TensorC *x1 = inputs[1];
   const TensorC *x2 = inputs[2];

mindspore/lite/nnacl/infer/arithmetic_infer.c

@@ -18,10 +18,12 @@
 
 int ArithmeticInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                          OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 2, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   ArithmeticParameter *param = (ArithmeticParameter *)parameter;
   param->broadcasting_ = false;

mindspore/lite/nnacl/infer/assign_add_infer.c

@@ -18,10 +18,13 @@
 
 int AssignAddInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                         OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *x = inputs[0];
   const TensorC *y = inputs[1];
   TensorC *out = outputs[0];

mindspore/lite/nnacl/infer/assign_infer.c

@@ -18,10 +18,12 @@
 
 int AssignInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   if (GetElementNum(inputs[0]) != GetElementNum(inputs[1])) {
     return NNACL_ERR;

mindspore/lite/nnacl/infer/audio_spectrogram_infer.c

@@ -39,10 +39,13 @@ uint32_t GetFftLength(uint32_t length) {
 
 int AudioSpectrogramInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                                OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/bias_grad_infer.c

@@ -18,10 +18,13 @@
 
 int BiasGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                        OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *in0 = inputs[0];
   TensorC *out = outputs[0];
 

mindspore/lite/nnacl/infer/bn_grad_infer.c

@@ -18,10 +18,13 @@
 
 int BnGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 6, 3);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *in = inputs[1];
   const TensorC *scale = inputs[2];
   if (in->shape_size_ != 4) {

mindspore/lite/nnacl/infer/cast_infer.c

@@ -18,10 +18,13 @@
 
 int CastInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullOutputSize(inputs, inputs_size, outputs, outputs_size, parameter, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   output->format_ = input->format_;

mindspore/lite/nnacl/infer/common_infer.h

@@ -45,8 +45,8 @@ typedef enum FormatC {
   Format_HW4 = 10,
   Format_NC = 11,
   Format_NC4 = 12,
-  Format_NC4HW4 = 100,
-  Format_NUM_OF_FORMAT = 101,
+  Format_NC4HW4 = 13,
+  Format_NUM_OF_FORMAT = 14,
   Format_MIN = Format_NCHW,
   Format_MAX = Format_NUM_OF_FORMAT
 } FormatC;

mindspore/lite/nnacl/infer/concat_infer.c

@@ -18,10 +18,12 @@
 
 int ConcatInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullOutputSize(inputs, inputs_size, outputs, outputs_size, parameter, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input0 = inputs[0];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/constant_of_shape_infer.c

@@ -18,10 +18,12 @@
 
 int ConstantOfShapeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                               OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *in_tensor = inputs[0];
   TensorC *out_tensor = outputs[0];

mindspore/lite/nnacl/infer/conv2d_infer.c

@@ -50,10 +50,13 @@ void ConvInferShape(int input_h, int input_w, int *output_h, int *output_w, Conv
 
 int Conv2dInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 2, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input_tensor = inputs[0];
   const TensorC *weight_tensor = inputs[1];
   TensorC *out_tensor = outputs[0];

mindspore/lite/nnacl/infer/crop_and_resize_infer.c

@@ -18,10 +18,12 @@
 
 int CropAndResizeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                             OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 4);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   if (input->shape_size_ != 0 && input->shape_size_ != 4) {

mindspore/lite/nnacl/infer/crop_infer.c

@@ -18,10 +18,13 @@
 
 int CropInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 2, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   SetDataTypeFormat(outputs[0], inputs[0]);
   if (!parameter->infer_flag_) {
     return NNACL_INFER_INVALID;

mindspore/lite/nnacl/infer/custom_extract_features_infer.c

@@ -18,10 +18,12 @@
 
 int CustomExtractFeaturesInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                     size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   TensorC *output0 = outputs[0];

mindspore/lite/nnacl/infer/custom_normalize_infer.c

@@ -18,10 +18,12 @@
 
 int CustomNormalizeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                               OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/custom_predict_infer.c

@@ -18,10 +18,13 @@
 
 int CustomPredictInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                             OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output0 = outputs[0];
   TensorC *output1 = outputs[1];

mindspore/lite/nnacl/infer/deconv2d_infer.c

@@ -18,10 +18,12 @@
 
 int Deconv2dInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                        OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   const TensorC *weight = inputs[1];

mindspore/lite/nnacl/infer/dedepthwise_conv2d_infer.c

@@ -18,10 +18,13 @@
 
 int DeDepthwiseConv2DInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                 size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 2, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/depth_to_space_infer.c

@@ -18,10 +18,12 @@
 
 int DepthToSpaceInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                            OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   if (input->format_ != Format_NHWC) {

mindspore/lite/nnacl/infer/depthwise_conv2d_infer.c

@@ -18,10 +18,13 @@
 
 int DepthwiseConv2dInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                               OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 2, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/detection_post_process_infer.c

@@ -18,10 +18,13 @@
 
 int DetectionPostProcessInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                    size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 3, 4);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *boxes = inputs[0];
   const TensorC *scores = inputs[1];
   const TensorC *anchors = inputs[2];

mindspore/lite/nnacl/infer/dropout_grad_infer.c

@@ -18,10 +18,13 @@
 
 int DropoutGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                           OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/dropout_infer.c

@@ -18,10 +18,12 @@
 
 int DropoutInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                       OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   TensorC *output0 = outputs[0];

mindspore/lite/nnacl/infer/embedding_lookup_infer.c

@@ -18,6 +18,7 @@
 
 int EmbeddingLookupInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                               OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
@@ -25,6 +26,8 @@ int EmbeddingLookupInferShape(const TensorC *const *inputs, size_t inputs_size,
   if (inputs_size < 2 || outputs_size != 1) {
     return NNACL_INPUT_TENSOR_ERROR;
   }
+#endif
+
   const TensorC *params_ = inputs[0];
   const TensorC *ids = inputs[inputs_size - 1];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/expand_dims_infer.c

@@ -18,10 +18,12 @@
 
 int ExpandDimsInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                          OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullOutputSize(inputs, inputs_size, outputs, outputs_size, parameter, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/fill_infer.c

@@ -18,10 +18,13 @@
 
 int FillInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 2, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/flatten_grad_infer.c

@@ -18,10 +18,13 @@
 
 int FlattenGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                           OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/flatten_infer.c

@@ -18,10 +18,13 @@
 
 int FlattenInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                       OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/full_connection_infer.c

@@ -18,10 +18,13 @@
 
 int FullConnectionInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                              OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input0 = inputs[0];
   const TensorC *input1 = inputs[1];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/gather_nd_infer.c

@@ -18,10 +18,13 @@
 
 int GatherNdInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                        OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 2, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   const TensorC *indices = inputs[1];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/gru_infer.c

@@ -18,13 +18,13 @@
 
 int GruInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                   OpParameter *parameter) {
-  int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
+#ifdef Debug
+  int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 5, 6, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
-  if ((inputs_size != 5 && inputs_size != 6) || outputs_size != 2) {
-    return NNACL_INPUT_TENSOR_ERROR;
-  }
+#endif
+
   const TensorC *input = inputs[0];
   const TensorC *weight_gate = inputs[1];
   const TensorC *weight_recurrence = inputs[2];

mindspore/lite/nnacl/infer/hashtable_lookup_infer.c

@@ -18,10 +18,13 @@
 
 int HashtableLoopupInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                               OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   const TensorC *values = inputs[2];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/invert_permutation_infer.c

@@ -18,10 +18,13 @@
 
 int InvertPermutationInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                 size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/layer_norm_infer.c

@@ -18,10 +18,13 @@
 
 int LayerNormInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                         OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 1, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/lin_space_infer.c

@@ -18,10 +18,13 @@
 
 int LinSpaceInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                        OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/lsh_projection_infer.c

@@ -18,10 +18,12 @@
 
 int LshProjectionInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                             OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 2, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *in_hash = inputs[0];
   if (in_hash->shape_size_ != 2 || GetDimensionSize(in_hash, 1) > 32) {

mindspore/lite/nnacl/infer/lstm_infer.c

@@ -18,10 +18,13 @@
 
 int LstmInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 6, 3);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   const TensorC *weight_i = inputs[1];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/matmul_infer.c

@@ -18,10 +18,13 @@
 
 int MatmulInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   TensorC *input0 = (TensorC *)inputs[0];
   TensorC *input1 = (TensorC *)inputs[1];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/maximum_grad_infer.c

@@ -18,10 +18,12 @@
 
 int MaximumGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                           OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 3, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *x1 = inputs[0];
   const TensorC *x2 = inputs[1];

mindspore/lite/nnacl/infer/mean_infer.c

@@ -18,10 +18,13 @@
 
 int MeanInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/merge_infer.c

@@ -53,6 +53,7 @@ int MergeInfer(const TensorC *const *inputs, size_t inputs_size, TensorC **outpu
 
 int MergeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                     OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
@@ -60,6 +61,8 @@ int MergeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **
   if (inputs_size != 2 * outputs_size) {
     return NNACL_ERR;
   }
+#endif
+
   if (!parameter->infer_flag_) {
     return NNACL_INFER_INVALID;
   }

mindspore/lite/nnacl/infer/mfcc_infer.c

@@ -18,10 +18,13 @@
 
 int MfccInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/non_max_suppression_infer.c

@@ -18,10 +18,13 @@
 
 int NonMaxSuppressionInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                 size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   output->data_type_ = kNumberTypeInt32;

mindspore/lite/nnacl/infer/one_hot_infer.c

@@ -18,6 +18,7 @@
 
 int OneHotInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
@@ -25,6 +26,7 @@ int OneHotInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC *
   if (inputs_size != 4 && inputs_size != 3) {
     return NNACL_INPUT_TENSOR_ERROR;
   }
+#endif
 
   const TensorC *input = inputs[0];
   const TensorC *depth_tensor = inputs[1];

mindspore/lite/nnacl/infer/pad_infer.c

@@ -18,10 +18,13 @@
 
 int PadInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                   OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/pooling_grad_infer.c

@@ -19,10 +19,13 @@
 
 int PoolingGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                           OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   int input_h = input->shape_[1];
   int input_w = input->shape_[2];

mindspore/lite/nnacl/infer/pooling_infer.c

@@ -19,10 +19,13 @@
 
 int PoolingInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                       OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/power_infer.c

@@ -18,10 +18,13 @@
 
 int PowerInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                     OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *x_tensor = inputs[0];
   TensorC *exp_tensor = NULL;
   if (inputs_size == 2) {

mindspore/lite/nnacl/infer/prior_box_infer.c

@@ -19,10 +19,13 @@
 
 int PriorBoxInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                        OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   output->data_type_ = kNumberTypeFloat32;

mindspore/lite/nnacl/infer/quant_dtype_cast_infer.c

@@ -18,10 +18,13 @@
 
 int QuantDtypeCastInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                              OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/random_standard_normal_infer.c

@@ -18,10 +18,13 @@
 
 int RandomStandardNormalInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                    size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   if (!parameter->infer_flag_) {
     return NNACL_INFER_INVALID;
   }

mindspore/lite/nnacl/infer/range_infer.c

@@ -19,10 +19,13 @@
 
 int RangeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                     OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   if (input == NULL || output == NULL) {

mindspore/lite/nnacl/infer/rank_infer.c

@@ -18,10 +18,13 @@
 
 int RankInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/reduce_infer.c

@@ -18,13 +18,13 @@
 
 int ReduceInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
-  int check_ret = CheckAugmentNullOutputSize(inputs, inputs_size, outputs, outputs_size, parameter, 1);
+#ifdef Debug
+  int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 2, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
-  if (inputs_size < 1) {
-    return NNACL_INPUT_TENSOR_ERROR;
-  }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/reshape_infer.c

@@ -129,10 +129,12 @@ int CalShapeByType(const TensorC *const *inputs, size_t shape_size, int *out_sha
 
 int ReshapeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                       OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/resize_infer.c

@@ -107,10 +107,13 @@ int CalculateNewHeightAndWidth(const TensorC *const *inputs, size_t inputs_size,
 
 int ResizeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   if (input->shape_size_ != 0 && input->shape_size_ != 4) {
     return NNACL_ERR;

mindspore/lite/nnacl/infer/rfft_infer.c

@@ -17,10 +17,13 @@
 #include "nnacl/infer/rfft_infer.h"
 int RfftInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   output->data_type_ = kNumberTypeComplex64;

mindspore/lite/nnacl/infer/roi_pooling_infer.c

@@ -18,13 +18,13 @@
 
 int ROIPoolingInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                          OpParameter *parameter) {
-  int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
+#ifdef Debug
+  int check_ret = CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
-  if (inputs_size != 2) {
-    return NNACL_INPUT_TENSOR_ERROR;
-  }
+#endif
+
   const TensorC *input = inputs[0];
   const TensorC *roi = inputs[1];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/scatter_nd_infer.c

@@ -18,10 +18,12 @@
 
 int ScatterNdInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                         OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *shape = inputs[0];
   if (shape->data_ == NULL) {

mindspore/lite/nnacl/infer/select_infer.c

@@ -19,11 +19,14 @@
 
 int SelectInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret =
     CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 2 * outputs_size + 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   if (!parameter->infer_flag_) {
     return NNACL_INFER_INVALID;
   }

mindspore/lite/nnacl/infer/sgd_infer.c

@@ -18,10 +18,12 @@
 
 int SgdInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                   OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullInputSize(inputs, inputs_size, outputs, outputs_size, parameter, 6);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   if (GetElementNum(inputs[0]) != GetElementNum(inputs[1]) || GetElementNum(inputs[0]) != GetElementNum(inputs[3]) ||
       GetElementNum(inputs[2]) != 1 || GetElementNum(inputs[4]) != 1) {

mindspore/lite/nnacl/infer/shape_infer.c

@@ -18,10 +18,12 @@
 
 int ShapeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                     OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *in_tensor = inputs[0];
   TensorC *out_tensor = outputs[0];

mindspore/lite/nnacl/infer/size_infer.c

@@ -18,10 +18,13 @@
 
 int SizeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *in_tensor = inputs[0];
   TensorC *out_tensor = outputs[0];
   out_tensor->data_type_ = kNumberTypeInt32;

mindspore/lite/nnacl/infer/skip_gram_infer.c

@@ -18,10 +18,12 @@
 
 int SkipGramInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                        OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];

mindspore/lite/nnacl/infer/softmax_cross_entropy_infer.c

@@ -18,6 +18,7 @@
 
 int SoftmaxCrossEntropyInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                   size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
@@ -25,6 +26,8 @@ int SoftmaxCrossEntropyInferShape(const TensorC *const *inputs, size_t inputs_si
   if (1 > outputs_size) {
     return NNACL_INPUT_TENSOR_ERROR;
   }
+#endif
+
   const TensorC *in0 = inputs[0];
   TensorC *out = outputs[0];
 

mindspore/lite/nnacl/infer/softmax_infer.c

@@ -18,10 +18,13 @@
 
 int SoftMaxInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                       OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/space_to_batch_infer.c

@@ -18,10 +18,12 @@
 
 int SpaceToBatchInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                            OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   if (input->format_ != Format_NHWC) {

mindspore/lite/nnacl/infer/space_to_batch_nd_infer.c

@@ -96,9 +96,12 @@ int SpaceSetOutputShapeFromInput(const TensorC *const *inputs, size_t inputs_siz
 
 int SpaceToBatchNdInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                              OpParameter *parameter) {
-  if (outputs_size != 1 || (inputs_size != 1 && inputs_size != 3)) {
-    return 1;
+#ifdef Debug
+  int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 1, 3, 1);
+  if (check_ret != NNACL_OK) {
+    return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   if (input->format_ != Format_NHWC) {

mindspore/lite/nnacl/infer/space_to_depth_infer.c

@@ -19,9 +19,12 @@
 
 int SpaceToDepthInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                            OpParameter *parameter) {
-  if (outputs_size != 1 || inputs_size != 1) {
-    return NNACL_ERR;
+#ifdef Debug
+  int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
+  if (check_ret != NNACL_OK) {
+    return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   if (input->format_ != Format_NHWC) {

mindspore/lite/nnacl/infer/sparse_softmax_cross_entropy_infer.c

@@ -18,10 +18,13 @@
 
 int SparseSoftmaxCrossEntropyInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                         size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 2, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *in0 = inputs[0];
   TensorC *out = outputs[0];
 

mindspore/lite/nnacl/infer/sparse_to_dense_infer.c

@@ -18,10 +18,13 @@
 
 int SparseToDenseInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                             OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   TensorC *output = outputs[0];
   const TensorC *input1 = inputs[1];
   const TensorC *input2 = inputs[2];

mindspore/lite/nnacl/infer/splice_infer.c

@@ -18,16 +18,13 @@
 
 int SpliceInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
-  int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
+#ifdef Debug
+  int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret == NNACL_NULL_PTR) {
     return NNACL_NULL_PTR;
   }
-  if (inputs_size != 1) {
-    return NNACL_ERR;
-  }
-  if (outputs_size != 1) {
-    return NNACL_ERR;
-  }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
   SetDataTypeFormat(output, input);

mindspore/lite/nnacl/infer/split_infer.c

@@ -18,10 +18,13 @@
 
 int SplitInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                     OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   if (inputs_size < 1) {
     return NNACL_ERR;

mindspore/lite/nnacl/infer/squeeze_infer.c

@@ -18,10 +18,12 @@
 
 int SqueezeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                       OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   SqueezeParameter *param = (SqueezeParameter *)parameter;

mindspore/lite/nnacl/infer/strided_slice_grad_infer.c

@@ -22,16 +22,17 @@ bool StridedSliceCheckInputs(const TensorC *const *inputs, size_t inputs_size) {
       return false;
     }
   }
-
   return true;  // note: the original code is ndim_ <= in_shape_size
 }
 
 int StridedSliceGradInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                                OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 5, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   SetDataTypeFormat(outputs[0], input);
@@ -58,9 +59,7 @@ int StridedSliceGradInferShape(const TensorC *const *inputs, size_t inputs_size,
   int *begin_data = (int *)(begin_tensor->data_);
   int *end_data = (int *)(inputs[3]->data_);
   int *stride_data = (int *)(inputs[4]->data_);
-  if (begin_data == NULL || end_data == NULL || stride_data == NULL) {
-    return NNACL_ERR;
-  }
+
   size_t ndim_ = GetElementNum(begin_tensor);
   for (int i = 0; i < ndim_; ++i) {
     ShapePush(begins_, &begins_size, begin_data[i]);

mindspore/lite/nnacl/infer/strided_slice_infer.c

@@ -131,6 +131,7 @@ int HandleAxesInputExist(const TensorC *const *inputs, int *ndim_, int *in_shape
 // note: begin, end, stride length are equal, but may less than rank of input
 int StridedSliceInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                            OpParameter *parameter) {
+#ifdef Debug
   if (outputs_size != kStridedSliceOutputNum) {
     return NNACL_PARAM_INVALID;
   }
@@ -141,6 +142,8 @@ int StridedSliceInferShape(const TensorC *const *inputs, size_t inputs_size, Ten
   if (parameter == NULL || outputs[0] == NULL || inputs[0] == NULL) {
     return NNACL_NULL_PTR;
   }
+#endif
+
   const TensorC *input = inputs[0];
   SetDataTypeFormat(outputs[0], inputs[0]);
 

mindspore/lite/nnacl/infer/switch_infer.c

@@ -19,6 +19,7 @@
 
 int SwitchInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
@@ -26,6 +27,7 @@ int SwitchInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC *
   if (2 * (inputs_size - 1) != outputs_size) {
     return NNACL_ERR;
   }
+#endif
 
   for (size_t i = 0; i < outputs_size / 2; i++) {
     const TensorC *input = inputs[i + 1];

mindspore/lite/nnacl/infer/tensorlist_fromtensor_infer.c

@@ -18,10 +18,13 @@
 
 int TensorListFromTensorInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                    size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   if (!parameter->infer_flag_) {
     return NNACL_INFER_INVALID;
   }

mindspore/lite/nnacl/infer/tensorlist_getitem_infer.c

@@ -18,10 +18,13 @@
 
 int TensorListGetItemInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                 size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   if (!parameter->infer_flag_) {
     return NNACL_INFER_INVALID;
   }

mindspore/lite/nnacl/infer/tensorlist_reserve_infer.c

@@ -18,10 +18,13 @@
 
 int TensorListReserveInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                 size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input0 = inputs[0];
   int ele_shape_type = input0->data_type_;
   if (ele_shape_type != kNumberTypeInt && ele_shape_type != kNumberTypeInt32) {

mindspore/lite/nnacl/infer/tensorlist_setitem_infer.c

@@ -35,10 +35,13 @@ int PreJudge(const TensorC *get_index, TensorListC *input0, const TensorC *value
 
 int TensorListSetItemInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                 size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   TensorListC *input0 = (TensorListC *)(inputs[0]);
   const TensorC *get_index = inputs[1];
   const TensorC *value_tensor = inputs[2];

mindspore/lite/nnacl/infer/tensorlist_stack_infer.c

@@ -18,10 +18,13 @@
 
 int TensorListStackInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                               OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   if (!parameter->infer_flag_) {
     return NNACL_INFER_INVALID;
   }

mindspore/lite/nnacl/infer/tile_infer.c

@@ -34,10 +34,13 @@ void TileParamCaffe2Tflite(TileParameter *param, size_t out_shape_size) {
 
 int TileInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/topk_infer.c

@@ -18,10 +18,13 @@
 
 int TopKInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                    OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSizeInputTwo(inputs, inputs_size, outputs, outputs_size, parameter, 1, 2, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   if (input->shape_size_ == 4 && input->format_ != Format_NHWC) {
     return NNACL_ERR;

mindspore/lite/nnacl/infer/transpose_infer.c

@@ -27,10 +27,13 @@ bool CheckPermTransFormat(const int *perm, const int *perm_transformat, const si
 
 int TransposeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                         OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 2, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/unique_infer.c

@@ -18,10 +18,12 @@
 
 int UniqueInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                      OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 2);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   TensorC *output0 = outputs[0];

mindspore/lite/nnacl/infer/unsorted_segment_sum_infer.c

@@ -18,10 +18,12 @@
 
 int UnsortedSegmentSumInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs,
                                  size_t outputs_size, OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 3, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   TensorC *out = outputs[0];
   const TensorC *x = inputs[0];

mindspore/lite/nnacl/infer/unsqueeze_infer.c

@@ -18,10 +18,13 @@
 
 int UnsqueezeInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                         OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNullSize(inputs, inputs_size, outputs, outputs_size, parameter, 1, 1);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];
 

mindspore/lite/nnacl/infer/unstack_infer.c

@@ -18,10 +18,13 @@
 
 int UnstackInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                       OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
+
   const TensorC *input = inputs[0];
   UnstackParameter *param = (UnstackParameter *)parameter;
   int axis = param->axis_ < 0 ? param->axis_ + input->shape_size_ : param->axis_;

mindspore/lite/nnacl/infer/where_infer.c

@@ -18,10 +18,12 @@
 
 int WhereInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                     OpParameter *parameter) {
+#ifdef Debug
   int check_ret = CheckAugmentNull(inputs, inputs_size, outputs, outputs_size, parameter);
   if (check_ret != NNACL_OK) {
     return check_ret;
   }
+#endif
 
   const TensorC *input = inputs[0];
   TensorC *output = outputs[0];