diff --git a/mindspore/lite/nnacl/infer/adam_infer.c b/mindspore/lite/nnacl/infer/adam_infer.c
index b8543ef7f0..458c652a45 100644
--- a/mindspore/lite/nnacl/infer/adam_infer.c
+++ b/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 ||
diff --git a/mindspore/lite/nnacl/infer/add_sub_grad_infer.c b/mindspore/lite/nnacl/infer/add_sub_grad_infer.c
index 69d5580778..7d64d987a6 100644
--- a/mindspore/lite/nnacl/infer/add_sub_grad_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/addn_infer.c b/mindspore/lite/nnacl/infer/addn_infer.c
index e571d06e9c..ebdcba8828 100644
--- a/mindspore/lite/nnacl/infer/addn_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/apply_momentum_infer.c b/mindspore/lite/nnacl/infer/apply_momentum_infer.c
index f12207c59d..78dee0ad3b 100644
--- a/mindspore/lite/nnacl/infer/apply_momentum_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/argmin_max_infer.c b/mindspore/lite/nnacl/infer/argmin_max_infer.c
index 362023f73c..e263cfdeee 100644
--- a/mindspore/lite/nnacl/infer/argmin_max_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/arithmetic_grad_infer.c b/mindspore/lite/nnacl/infer/arithmetic_grad_infer.c
index 591732a7c6..ff5d7f334d 100644
--- a/mindspore/lite/nnacl/infer/arithmetic_grad_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/arithmetic_infer.c b/mindspore/lite/nnacl/infer/arithmetic_infer.c
index 466813b8a1..216c35a6e7 100644
--- a/mindspore/lite/nnacl/infer/arithmetic_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/assign_add_infer.c b/mindspore/lite/nnacl/infer/assign_add_infer.c
index 807c9fd7b6..a52e7a8760 100644
--- a/mindspore/lite/nnacl/infer/assign_add_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/assign_infer.c b/mindspore/lite/nnacl/infer/assign_infer.c
index fcdf7a0ef5..9f83782e2e 100644
--- a/mindspore/lite/nnacl/infer/assign_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/audio_spectrogram_infer.c b/mindspore/lite/nnacl/infer/audio_spectrogram_infer.c
index 6f566f89f0..c4e256ca41 100644
--- a/mindspore/lite/nnacl/infer/audio_spectrogram_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/bias_grad_infer.c b/mindspore/lite/nnacl/infer/bias_grad_infer.c
index 7cf1d678e7..a1206872d9 100644
--- a/mindspore/lite/nnacl/infer/bias_grad_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/bn_grad_infer.c b/mindspore/lite/nnacl/infer/bn_grad_infer.c
index 9d4a921ae1..50ab35f740 100644
--- a/mindspore/lite/nnacl/infer/bn_grad_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/cast_infer.c b/mindspore/lite/nnacl/infer/cast_infer.c
index 8b84d95b1b..db1afe0e42 100644
--- a/mindspore/lite/nnacl/infer/cast_infer.c
+++ b/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_;
diff --git a/mindspore/lite/nnacl/infer/common_infer.h b/mindspore/lite/nnacl/infer/common_infer.h
index b7b39267b1..e7a32ac8b3 100644
--- a/mindspore/lite/nnacl/infer/common_infer.h
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/concat_infer.c b/mindspore/lite/nnacl/infer/concat_infer.c
index 330801c16b..d5c3fa7d2d 100644
--- a/mindspore/lite/nnacl/infer/concat_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/constant_of_shape_infer.c b/mindspore/lite/nnacl/infer/constant_of_shape_infer.c
index 49bd00995e..2f182014f1 100644
--- a/mindspore/lite/nnacl/infer/constant_of_shape_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/conv2d_infer.c b/mindspore/lite/nnacl/infer/conv2d_infer.c
index 5a64063a3c..3e807db8e4 100644
--- a/mindspore/lite/nnacl/infer/conv2d_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/crop_and_resize_infer.c b/mindspore/lite/nnacl/infer/crop_and_resize_infer.c
index fdbdbd9e53..879be97d4a 100644
--- a/mindspore/lite/nnacl/infer/crop_and_resize_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/crop_infer.c b/mindspore/lite/nnacl/infer/crop_infer.c
index f815d30773..db5545dc0e 100644
--- a/mindspore/lite/nnacl/infer/crop_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/custom_extract_features_infer.c b/mindspore/lite/nnacl/infer/custom_extract_features_infer.c
index 4fa4a09b0d..72539bdbea 100644
--- a/mindspore/lite/nnacl/infer/custom_extract_features_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/custom_normalize_infer.c b/mindspore/lite/nnacl/infer/custom_normalize_infer.c
index 5ed8b9f323..51909b66ed 100644
--- a/mindspore/lite/nnacl/infer/custom_normalize_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/custom_predict_infer.c b/mindspore/lite/nnacl/infer/custom_predict_infer.c
index bd119033cd..6ece4be71f 100644
--- a/mindspore/lite/nnacl/infer/custom_predict_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/deconv2d_infer.c b/mindspore/lite/nnacl/infer/deconv2d_infer.c
index 2f37906834..c735761c55 100644
--- a/mindspore/lite/nnacl/infer/deconv2d_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/dedepthwise_conv2d_infer.c b/mindspore/lite/nnacl/infer/dedepthwise_conv2d_infer.c
index a62c311a20..20ac637687 100644
--- a/mindspore/lite/nnacl/infer/dedepthwise_conv2d_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/depth_to_space_infer.c b/mindspore/lite/nnacl/infer/depth_to_space_infer.c
index 81fdb94006..4f7fc277bf 100644
--- a/mindspore/lite/nnacl/infer/depth_to_space_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/depthwise_conv2d_infer.c b/mindspore/lite/nnacl/infer/depthwise_conv2d_infer.c
index 9a60c6006a..7ae3aeb564 100644
--- a/mindspore/lite/nnacl/infer/depthwise_conv2d_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/detection_post_process_infer.c b/mindspore/lite/nnacl/infer/detection_post_process_infer.c
index 4a5a883507..aff19762c1 100644
--- a/mindspore/lite/nnacl/infer/detection_post_process_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/dropout_grad_infer.c b/mindspore/lite/nnacl/infer/dropout_grad_infer.c
index b759ae93ed..7d7f8e2ce0 100644
--- a/mindspore/lite/nnacl/infer/dropout_grad_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/dropout_infer.c b/mindspore/lite/nnacl/infer/dropout_infer.c
index c5ca932d9c..d2d32becd4 100644
--- a/mindspore/lite/nnacl/infer/dropout_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/embedding_lookup_infer.c b/mindspore/lite/nnacl/infer/embedding_lookup_infer.c
index 4d58ebbcbb..fbc16e0934 100644
--- a/mindspore/lite/nnacl/infer/embedding_lookup_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/expand_dims_infer.c b/mindspore/lite/nnacl/infer/expand_dims_infer.c
index 08d1691eac..8d22a05902 100644
--- a/mindspore/lite/nnacl/infer/expand_dims_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/fill_infer.c b/mindspore/lite/nnacl/infer/fill_infer.c
index 8f68e035e6..4e6a9d478d 100644
--- a/mindspore/lite/nnacl/infer/fill_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/flatten_grad_infer.c b/mindspore/lite/nnacl/infer/flatten_grad_infer.c
index 96d96f59ec..117fdea4ae 100644
--- a/mindspore/lite/nnacl/infer/flatten_grad_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/flatten_infer.c b/mindspore/lite/nnacl/infer/flatten_infer.c
index 217ce0c62e..d6ac84691f 100644
--- a/mindspore/lite/nnacl/infer/flatten_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/full_connection_infer.c b/mindspore/lite/nnacl/infer/full_connection_infer.c
index 6e3e9c2382..fda4009b03 100644
--- a/mindspore/lite/nnacl/infer/full_connection_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/gather_nd_infer.c b/mindspore/lite/nnacl/infer/gather_nd_infer.c
index 98ac806526..13db7b7443 100644
--- a/mindspore/lite/nnacl/infer/gather_nd_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/gru_infer.c b/mindspore/lite/nnacl/infer/gru_infer.c
index 61bd5c1eeb..e5a6b3a2e3 100644
--- a/mindspore/lite/nnacl/infer/gru_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/hashtable_lookup_infer.c b/mindspore/lite/nnacl/infer/hashtable_lookup_infer.c
index a01525c4e9..077d293043 100644
--- a/mindspore/lite/nnacl/infer/hashtable_lookup_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/invert_permutation_infer.c b/mindspore/lite/nnacl/infer/invert_permutation_infer.c
index d7448eecb1..e72c6917ce 100644
--- a/mindspore/lite/nnacl/infer/invert_permutation_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/layer_norm_infer.c b/mindspore/lite/nnacl/infer/layer_norm_infer.c
index bfa9e51d67..92f2e15b69 100644
--- a/mindspore/lite/nnacl/infer/layer_norm_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/lin_space_infer.c b/mindspore/lite/nnacl/infer/lin_space_infer.c
index 5a3d1c3bf6..60d31a0e4e 100644
--- a/mindspore/lite/nnacl/infer/lin_space_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/lsh_projection_infer.c b/mindspore/lite/nnacl/infer/lsh_projection_infer.c
index b5e170874a..47f7aa66f3 100644
--- a/mindspore/lite/nnacl/infer/lsh_projection_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/lstm_infer.c b/mindspore/lite/nnacl/infer/lstm_infer.c
index 2f30704260..e9ed86f7e5 100644
--- a/mindspore/lite/nnacl/infer/lstm_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/matmul_infer.c b/mindspore/lite/nnacl/infer/matmul_infer.c
index aff275b15f..c0e21beff9 100644
--- a/mindspore/lite/nnacl/infer/matmul_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/maximum_grad_infer.c b/mindspore/lite/nnacl/infer/maximum_grad_infer.c
index f35561795f..594f7137d3 100644
--- a/mindspore/lite/nnacl/infer/maximum_grad_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/mean_infer.c b/mindspore/lite/nnacl/infer/mean_infer.c
index 1b22283b80..f9f056af50 100644
--- a/mindspore/lite/nnacl/infer/mean_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/merge_infer.c b/mindspore/lite/nnacl/infer/merge_infer.c
index 713650747d..7660f169db 100644
--- a/mindspore/lite/nnacl/infer/merge_infer.c
+++ b/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;
   }
diff --git a/mindspore/lite/nnacl/infer/mfcc_infer.c b/mindspore/lite/nnacl/infer/mfcc_infer.c
index f47e849b36..41b0b3eaff 100644
--- a/mindspore/lite/nnacl/infer/mfcc_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/non_max_suppression_infer.c b/mindspore/lite/nnacl/infer/non_max_suppression_infer.c
index 740e958a87..4e5313ae09 100644
--- a/mindspore/lite/nnacl/infer/non_max_suppression_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/one_hot_infer.c b/mindspore/lite/nnacl/infer/one_hot_infer.c
index aec2a7d161..dec08de885 100644
--- a/mindspore/lite/nnacl/infer/one_hot_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/pad_infer.c b/mindspore/lite/nnacl/infer/pad_infer.c
index c2cd67d8ce..eaf328f3b8 100644
--- a/mindspore/lite/nnacl/infer/pad_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/pooling_grad_infer.c b/mindspore/lite/nnacl/infer/pooling_grad_infer.c
index c5b0d3e2b9..31f759cb4e 100644
--- a/mindspore/lite/nnacl/infer/pooling_grad_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/pooling_infer.c b/mindspore/lite/nnacl/infer/pooling_infer.c
index d301854f96..44803ccabc 100644
--- a/mindspore/lite/nnacl/infer/pooling_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/power_infer.c b/mindspore/lite/nnacl/infer/power_infer.c
index aa45b38167..366cce464a 100644
--- a/mindspore/lite/nnacl/infer/power_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/prior_box_infer.c b/mindspore/lite/nnacl/infer/prior_box_infer.c
index cba8185204..833722ec04 100644
--- a/mindspore/lite/nnacl/infer/prior_box_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/quant_dtype_cast_infer.c b/mindspore/lite/nnacl/infer/quant_dtype_cast_infer.c
index c904a066ce..98eddceb4d 100644
--- a/mindspore/lite/nnacl/infer/quant_dtype_cast_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/random_standard_normal_infer.c b/mindspore/lite/nnacl/infer/random_standard_normal_infer.c
index d3b175fc06..22bd8a1856 100644
--- a/mindspore/lite/nnacl/infer/random_standard_normal_infer.c
+++ b/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;
   }
diff --git a/mindspore/lite/nnacl/infer/range_infer.c b/mindspore/lite/nnacl/infer/range_infer.c
index 51b06ba2a8..b6cd282e8b 100644
--- a/mindspore/lite/nnacl/infer/range_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/rank_infer.c b/mindspore/lite/nnacl/infer/rank_infer.c
index 56c53920c8..338786f47a 100644
--- a/mindspore/lite/nnacl/infer/rank_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/reduce_infer.c b/mindspore/lite/nnacl/infer/reduce_infer.c
index 7d1d744e8b..fbda6901e5 100644
--- a/mindspore/lite/nnacl/infer/reduce_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/reshape_infer.c b/mindspore/lite/nnacl/infer/reshape_infer.c
index 81516fac1d..92cd72eca0 100644
--- a/mindspore/lite/nnacl/infer/reshape_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/resize_infer.c b/mindspore/lite/nnacl/infer/resize_infer.c
index 71c077af70..36e3c3e1e8 100644
--- a/mindspore/lite/nnacl/infer/resize_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/rfft_infer.c b/mindspore/lite/nnacl/infer/rfft_infer.c
index 093ff691de..a1e0593027 100644
--- a/mindspore/lite/nnacl/infer/rfft_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/roi_pooling_infer.c b/mindspore/lite/nnacl/infer/roi_pooling_infer.c
index 488364771d..f082feb047 100644
--- a/mindspore/lite/nnacl/infer/roi_pooling_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/scatter_nd_infer.c b/mindspore/lite/nnacl/infer/scatter_nd_infer.c
index f40edf5320..ad034fbc05 100644
--- a/mindspore/lite/nnacl/infer/scatter_nd_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/select_infer.c b/mindspore/lite/nnacl/infer/select_infer.c
index 68bd38353c..a42c108206 100644
--- a/mindspore/lite/nnacl/infer/select_infer.c
+++ b/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;
   }
diff --git a/mindspore/lite/nnacl/infer/sgd_infer.c b/mindspore/lite/nnacl/infer/sgd_infer.c
index 71da6844d2..047fb1f907 100644
--- a/mindspore/lite/nnacl/infer/sgd_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/shape_infer.c b/mindspore/lite/nnacl/infer/shape_infer.c
index b2110b4a8c..62dd25ae52 100644
--- a/mindspore/lite/nnacl/infer/shape_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/size_infer.c b/mindspore/lite/nnacl/infer/size_infer.c
index f110ce0014..0b5587c58a 100644
--- a/mindspore/lite/nnacl/infer/size_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/skip_gram_infer.c b/mindspore/lite/nnacl/infer/skip_gram_infer.c
index 5517abfd80..857632f1be 100644
--- a/mindspore/lite/nnacl/infer/skip_gram_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/softmax_cross_entropy_infer.c b/mindspore/lite/nnacl/infer/softmax_cross_entropy_infer.c
index 5b78c4d102..394625ecd0 100644
--- a/mindspore/lite/nnacl/infer/softmax_cross_entropy_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/softmax_infer.c b/mindspore/lite/nnacl/infer/softmax_infer.c
index 39fd8ff999..19167bf8d6 100644
--- a/mindspore/lite/nnacl/infer/softmax_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/space_to_batch_infer.c b/mindspore/lite/nnacl/infer/space_to_batch_infer.c
index 0eb146052b..21f48c8267 100644
--- a/mindspore/lite/nnacl/infer/space_to_batch_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/space_to_batch_nd_infer.c b/mindspore/lite/nnacl/infer/space_to_batch_nd_infer.c
index 0cc350a96c..ef89043bf2 100644
--- a/mindspore/lite/nnacl/infer/space_to_batch_nd_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/space_to_depth_infer.c b/mindspore/lite/nnacl/infer/space_to_depth_infer.c
index 7baaaaade9..803925c2f0 100644
--- a/mindspore/lite/nnacl/infer/space_to_depth_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/sparse_softmax_cross_entropy_infer.c b/mindspore/lite/nnacl/infer/sparse_softmax_cross_entropy_infer.c
index 5d8b7991b7..6382a5188e 100644
--- a/mindspore/lite/nnacl/infer/sparse_softmax_cross_entropy_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/sparse_to_dense_infer.c b/mindspore/lite/nnacl/infer/sparse_to_dense_infer.c
index 486df3ef19..1bb8b3092d 100644
--- a/mindspore/lite/nnacl/infer/sparse_to_dense_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/splice_infer.c b/mindspore/lite/nnacl/infer/splice_infer.c
index 74468f743b..9fbd929850 100644
--- a/mindspore/lite/nnacl/infer/splice_infer.c
+++ b/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);
diff --git a/mindspore/lite/nnacl/infer/split_infer.c b/mindspore/lite/nnacl/infer/split_infer.c
index 8a4f139325..faeed864e3 100644
--- a/mindspore/lite/nnacl/infer/split_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/squeeze_infer.c b/mindspore/lite/nnacl/infer/squeeze_infer.c
index 2ed2f52eaa..56edc250de 100644
--- a/mindspore/lite/nnacl/infer/squeeze_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/strided_slice_grad_infer.c b/mindspore/lite/nnacl/infer/strided_slice_grad_infer.c
index 6de2337a29..457994a051 100644
--- a/mindspore/lite/nnacl/infer/strided_slice_grad_infer.c
+++ b/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]);
diff --git a/mindspore/lite/nnacl/infer/strided_slice_infer.c b/mindspore/lite/nnacl/infer/strided_slice_infer.c
index ad37aa247b..b7d336519b 100644
--- a/mindspore/lite/nnacl/infer/strided_slice_infer.c
+++ b/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]);
 
diff --git a/mindspore/lite/nnacl/infer/switch_infer.c b/mindspore/lite/nnacl/infer/switch_infer.c
index 642fa75679..8a1e94f707 100644
--- a/mindspore/lite/nnacl/infer/switch_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/tensorlist_fromtensor_infer.c b/mindspore/lite/nnacl/infer/tensorlist_fromtensor_infer.c
index a3cb64460f..69d4c7869b 100644
--- a/mindspore/lite/nnacl/infer/tensorlist_fromtensor_infer.c
+++ b/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;
   }
diff --git a/mindspore/lite/nnacl/infer/tensorlist_getitem_infer.c b/mindspore/lite/nnacl/infer/tensorlist_getitem_infer.c
index 36354bd6ba..c3a427f9f0 100644
--- a/mindspore/lite/nnacl/infer/tensorlist_getitem_infer.c
+++ b/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;
   }
diff --git a/mindspore/lite/nnacl/infer/tensorlist_reserve_infer.c b/mindspore/lite/nnacl/infer/tensorlist_reserve_infer.c
index e53e3c3474..17738d31e3 100644
--- a/mindspore/lite/nnacl/infer/tensorlist_reserve_infer.c
+++ b/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) {
diff --git a/mindspore/lite/nnacl/infer/tensorlist_setitem_infer.c b/mindspore/lite/nnacl/infer/tensorlist_setitem_infer.c
index ec88854ba7..3f64ef83f7 100644
--- a/mindspore/lite/nnacl/infer/tensorlist_setitem_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/tensorlist_stack_infer.c b/mindspore/lite/nnacl/infer/tensorlist_stack_infer.c
index 6519a05f1f..2dfdd31edc 100644
--- a/mindspore/lite/nnacl/infer/tensorlist_stack_infer.c
+++ b/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;
   }
diff --git a/mindspore/lite/nnacl/infer/tile_infer.c b/mindspore/lite/nnacl/infer/tile_infer.c
index c4a6e1954b..94af483302 100644
--- a/mindspore/lite/nnacl/infer/tile_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/topk_infer.c b/mindspore/lite/nnacl/infer/topk_infer.c
index 8b851e50e5..eea6a99dc1 100644
--- a/mindspore/lite/nnacl/infer/topk_infer.c
+++ b/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;
diff --git a/mindspore/lite/nnacl/infer/transpose_infer.c b/mindspore/lite/nnacl/infer/transpose_infer.c
index 2780fcc38a..3c3909df9c 100644
--- a/mindspore/lite/nnacl/infer/transpose_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/unique_infer.c b/mindspore/lite/nnacl/infer/unique_infer.c
index 46721dc046..66d9be89fb 100644
--- a/mindspore/lite/nnacl/infer/unique_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/unsorted_segment_sum_infer.c b/mindspore/lite/nnacl/infer/unsorted_segment_sum_infer.c
index ea382d139a..ea752b9bef 100644
--- a/mindspore/lite/nnacl/infer/unsorted_segment_sum_infer.c
+++ b/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];
diff --git a/mindspore/lite/nnacl/infer/unsqueeze_infer.c b/mindspore/lite/nnacl/infer/unsqueeze_infer.c
index 9e8f6b4f35..12230b8e16 100644
--- a/mindspore/lite/nnacl/infer/unsqueeze_infer.c
+++ b/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];
 
diff --git a/mindspore/lite/nnacl/infer/unstack_infer.c b/mindspore/lite/nnacl/infer/unstack_infer.c
index 4e8971a740..0cd7795b6c 100644
--- a/mindspore/lite/nnacl/infer/unstack_infer.c
+++ b/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_;
diff --git a/mindspore/lite/nnacl/infer/where_infer.c b/mindspore/lite/nnacl/infer/where_infer.c
index 88e84a1c84..0393e3ff5b 100644
--- a/mindspore/lite/nnacl/infer/where_infer.c
+++ b/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];