Add prim name to error message for other operators left

mindspore/ops/operations/_quant_ops.py

@@ -15,8 +15,8 @@
 
 """Operators for quantization."""
 
-from ..._checkparam import ParamValidator as validator
-from ..._checkparam import Rel, check_bool, check_int_positive, check_int
+from ..._checkparam import Validator as validator
+from ..._checkparam import Rel
 from ..primitive import PrimitiveWithInfer, prim_attr_register
 from ...common import dtype as mstype
 
@@ -69,36 +69,31 @@ class FakeQuantWithMinMax(PrimitiveWithInfer):
                  training=True):
         """init FakeQuantWithMinMax OP"""
         if num_bits not in self.support_quant_bit:
-            raise ValueError("Attr \'num_bits\' is not support.")
+            raise ValueError(f"For '{self.name}' attr \'num_bits\' is not support.")
         if ema and not ema_decay:
-            raise ValueError(
-                "Attr \'ema\' and \'ema_decay\' should set together.")
-
-        self.ema = check_bool(ema)
-        self.symmetric = check_bool(symmetric)
-        self.narrow_range = check_bool(narrow_range)
-        self.training = check_bool(training)
-        self.ema_decay = validator.check_number_range(
-            'ema_decay', ema_decay, 0, 1, Rel.INC_BOTH)
-        self.num_bits = check_int_positive(num_bits)
-        self.quant_delay = check_int(quant_delay)
+            raise ValueError(f"For '{self.name}' attr \'ema\' and \'ema_decay\' should set together.")
+
+        self.ema = validator.check_value_type('ema', ema, (bool,), self.name)
+        self.symmetric = validator.check_value_type('symmetric', symmetric, (bool,), self.name)
+        self.narrow_range = validator.check_value_type('narrow_range', narrow_range, (bool,), self.name)
+        self.training = validator.check_value_type('training', training, (bool,), self.name)
+        self.ema_decay = validator.check_number_range('ema_decay', ema_decay, 0, 1, Rel.INC_BOTH, self.name)
+        self.num_bits = validator.check_integer('num_bits', num_bits, 0, Rel.GT, self.name)
+        self.quant_delay = validator.check_value_type('quant_delay', quant_delay, (int,), self.name)
         self.init_prim_io_names(inputs=['x', 'min', 'max'],
                                 outputs=['out'])
 
     def infer_shape(self, x_shape, min_shape, max_shape):
-        validator.check_integer("x shape", len(x_shape), 1, Rel.GT)
-        validator.check("min shape", min_shape, "max shape", max_shape)
-        validator.check_integer("min shape", len(min_shape), 1, Rel.EQ)
-        validator.check_integer("max shape", len(min_shape), 1, Rel.EQ)
+        validator.check_integer("x rank", len(x_shape), 1, Rel.GT, self.name)
+        validator.check("min shape", min_shape, "max shape", max_shape, Rel.EQ, self.name)
+        validator.check_integer("min rank", len(min_shape), 1, Rel.EQ, self.name)
         return x_shape
 
     def infer_dtype(self, x_type, min_type, max_type):
-        validator.check_typename(
-            "x type", x_type, (mstype.float16, mstype.float32))
-        validator.check_typename("min type", min_type,
-                                 (mstype.float16, mstype.float32))
-        validator.check_typename("max type", max_type,
-                                 (mstype.float16, mstype.float32))
+        valid_types = (mstype.float16, mstype.float32)
+        validator.check_tensor_type_same({"x": x_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"min": min_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"max": max_type}, valid_types, self.name)
         return x_type
 
 
@@ -109,29 +104,24 @@ class FakeQuantWithMinMaxGrad(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, num_bits=8, quant_delay=0):
         if num_bits not in self.support_quant_bit:
-            raise ValueError("Attr \'num_bits\' is not support.")
+            raise ValueError(f"For '{self.name}' attr \'num_bits\' is not support.")
 
-        self.quant_delay = check_int(quant_delay)
-        self.num_bits = check_int_positive(num_bits)
-        self.init_prim_io_names(inputs=['dout', 'x', 'min', 'max'],
-                                outputs=['dx'])
+        self.quant_delay = validator.check_value_type('quant_delay', quant_delay, (int,), self.name)
+        self.num_bits = validator.check_integer('num_bits', num_bits, 0, Rel.GT, self.name)
+        self.init_prim_io_names(inputs=['dout', 'x', 'min', 'max'], outputs=['dx'])
 
     def infer_shape(self, dout_shape, x_shape, min_shape, max_shape):
-        validator.check("dout shape", dout_shape, "x shape", x_shape)
-        validator.check("min shape", min_shape, "max shape", max_shape)
-        validator.check_integer("min shape", len(min_shape), 1, Rel.EQ)
-        validator.check_integer("max shape", len(min_shape), 1, Rel.EQ)
+        validator.check("dout shape", dout_shape, "x shape", x_shape, Rel.EQ, self.name)
+        validator.check("min shape", min_shape, "max shape", max_shape, Rel.EQ, self.name)
+        validator.check_integer("min rank", len(min_shape), 1, Rel.EQ, self.name)
         return dout_shape
 
     def infer_dtype(self, dout_type, x_type, min_type, max_type):
-        validator.check_typename(
-            "dout type", dout_type, (mstype.float16, mstype.float32))
-        validator.check_typename(
-            "x type", x_type, (mstype.float16, mstype.float32))
-        validator.check_typename("min type", min_type,
-                                 (mstype.float16, mstype.float32))
-        validator.check_typename("max type", max_type,
-                                 (mstype.float16, mstype.float32))
+        valid_types = (mstype.float16, mstype.float32)
+        validator.check_tensor_type_same({"dout": dout_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"x": x_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"min": min_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"max": max_type}, valid_types, self.name)
         return dout_type
 
 
@@ -172,37 +162,30 @@ class FakeQuantWithMinMaxPerChannel(PrimitiveWithInfer):
                  training=True):
         """init FakeQuantWithMinMaxPerChannel OP"""
         if num_bits not in self.support_quant_bit:
-            raise ValueError("Attr \'num_bits\' is not support.")
+            raise ValueError(f"For '{self.name}' Attr \'num_bits\' is not support.")
         if ema and not ema_decay:
-            raise ValueError(
-                "Attr \'ema\' and \'ema_decay\' should set together.")
-
-        self.ema = check_bool(ema)
-        self.symmetric = check_bool(symmetric)
-        self.narrow_range = check_bool(narrow_range)
-        self.training = check_bool(training)
-        self.ema_decay = validator.check_number_range(
-            'ema_decay', ema_decay, 0, 1, Rel.INC_BOTH)
-        self.num_bits = check_int_positive(num_bits)
-        self.quant_delay = check_int(quant_delay)
-        self.init_prim_io_names(inputs=['x', 'min', 'max'],
-                                outputs=['out'])
+            raise ValueError(f"For '{self.name}' attr \'ema\' and \'ema_decay\' should set together.")
+
+        self.ema = validator.check_value_type('ema', ema, (bool,), self.name)
+        self.symmetric = validator.check_value_type('symmetric', symmetric, (bool,), self.name)
+        self.narrow_range = validator.check_value_type('narrow_range', narrow_range, (bool,), self.name)
+        self.training = validator.check_value_type('training', training, (bool,), self.name)
+        self.ema_decay = validator.check_number_range('ema_decay', ema_decay, 0, 1, Rel.INC_BOTH, self.name)
+        self.num_bits = validator.check_integer('num_bits', num_bits, 0, Rel.GT, self.name)
+        self.quant_delay = validator.check_value_type('quant_delay', quant_delay, (int,), self.name)
+        self.init_prim_io_names(inputs=['x', 'min', 'max'], outputs=['out'])
 
     def infer_shape(self, x_shape, min_shape, max_shape):
-        validator.check_integer("x shape", len(x_shape), 1, Rel.GT)
-        validator.check_integer(
-            "min len", min_shape[0], x_shape[self.channel_idx], Rel.EQ)
-        validator.check_integer(
-            "max len", max_shape[0], x_shape[self.channel_idx], Rel.EQ)
+        validator.check_integer("x rank", len(x_shape), 1, Rel.GT, self.name)
+        validator.check_integer("min shape[0]", min_shape[0], x_shape[self.channel_idx], Rel.EQ, self.name)
+        validator.check_integer("max shape[0]", max_shape[0], x_shape[self.channel_idx], Rel.EQ, self.name)
         return x_shape
 
     def infer_dtype(self, x_type, min_type, max_type):
-        validator.check_typename(
-            "x type", x_type, (mstype.float16, mstype.float32))
-        validator.check_typename("min type", min_type,
-                                 (mstype.float16, mstype.float32))
-        validator.check_typename("max type", max_type,
-                                 (mstype.float16, mstype.float32))
+        valid_types = (mstype.float16, mstype.float32)
+        validator.check_tensor_type_same({"x": x_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"min": min_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"max": max_type}, valid_types, self.name)
         return x_type
 
 
@@ -214,12 +197,11 @@ class FakeQuantWithMinMaxPerChannelGrad(PrimitiveWithInfer):
     def __init__(self, num_bits=8, quant_delay=0):
         """init FakeQuantWithMinMaxPerChannel Fill"""
         if num_bits not in self.support_quant_bit:
-            raise ValueError("Attr \'num_bits\' is not support.")
+            raise ValueError(f"For '{self.name}' attr \'num_bits\' is not support.")
 
-        self.quant_delay = check_int(quant_delay)
-        self.num_bits = check_int_positive(num_bits)
-        self.init_prim_io_names(inputs=['dout', 'x', 'min', 'max'],
-                                outputs=['dx'])
+        self.quant_delay = validator.check_value_type('quant_delay', quant_delay, (int,), self.name)
+        self.num_bits = validator.check_integer('num_bits', num_bits, 0, Rel.GT, self.name)
+        self.init_prim_io_names(inputs=['dout', 'x', 'min', 'max'], outputs=['dx'])
 
     def infer_shape(self, dout_shape, x_shape, min_shape, max_shape):
         validator.check("dout shape", dout_shape, "x shape", x_shape)
@@ -227,13 +209,11 @@ class FakeQuantWithMinMaxPerChannelGrad(PrimitiveWithInfer):
         return dout_shape
 
     def infer_dtype(self, dout_type, x_type, min_type, max_type):
-        validator.check_typename(
-            "dout", dout_type, (mstype.float16, mstype.float32))
-        validator.check_typename("x", x_type, (mstype.float16, mstype.float32))
-        validator.check_typename(
-            "min", min_type, (mstype.float16, mstype.float32))
-        validator.check_typename(
-            "max", max_type, (mstype.float16, mstype.float32))
+        valid_types = (mstype.float16, mstype.float32)
+        validator.check_tensor_type_same({"dout": dout_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"x": x_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"min": min_type}, valid_types, self.name)
+        validator.check_tensor_type_same({"max": max_type}, valid_types, self.name)
         return dout_type
 
 
@@ -269,31 +249,26 @@ class BatchNormFold(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, momentum=0.1, epsilon=1e-12, is_training=True, freeze_bn=0):
         """init batch norm fold layer"""
-        self.momentum = validator.check_number_range(
-            'momentum', momentum, 0, 1, Rel.INC_BOTH)
-        self.epsilon = validator.check_float_positive('epsilon', epsilon)
-        self.is_training = check_bool(is_training)
-        self.freeze_bn = check_int(freeze_bn)
+        self.momentum = validator.check_number_range('momentum', momentum, 0, 1, Rel.INC_BOTH, self.name)
+        self.epsilon = validator.check_float_positive('epsilon', epsilon, self.name)
+        self.is_training = validator.check_value_type('is_training', is_training, (bool,), self.name)
+        self.freeze_bn = validator.check_value_type('freeze_bn', freeze_bn, (int,), self.name)
 
         self.init_prim_io_names(inputs=['x', 'mean', 'variance', 'global_step'],
                                 outputs=['batch_mean', 'batch_std', 'running_mean', 'running_std'])
 
     def infer_shape(self, x_shape, mean_shape, variance_shape, global_step_shape):
-        validator.check("mean shape", mean_shape,
-                        "gamma_shape", variance_shape)
-        validator.check("mean_shape size",
-                        mean_shape[0], "input channel", x_shape[self.channel])
-        validator.check_integer("global_step shape",
-                                len(global_step_shape), 1, Rel.EQ)
+        validator.check("mean shape", mean_shape, "gamma_shape", variance_shape, Rel.EQ, self.name)
+        validator.check("mean_shape[0]", mean_shape[0], "input channel", x_shape[self.channel], Rel.EQ, self.name)
+        validator.check_integer("global_step rank", len(global_step_shape), 1, Rel.EQ, self.name)
         return mean_shape, mean_shape, mean_shape, mean_shape
 
     def infer_dtype(self, x_type, mean_type, variance_type, global_step_type):
         validator.check("input type", x_type, "mean type", mean_type)
         validator.check("input type", x_type, "variance type", variance_type)
-        validator.check_typename("input type", x_type,
-                                 (mstype.float16, mstype.float32))
-        validator.check_typename(
-            "global_step type", global_step_type, (mstype.int32,))
+        args = {"x": x_type, "mean": mean_type, "variance": variance_type}
+        validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
+        validator.check_tensor_type_same({"global_step": global_step_type}, (mstype.int32,), self.name)
         return x_type, x_type, x_type, x_type
 
 
@@ -304,39 +279,31 @@ class BatchNormFoldGrad(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, epsilon=1e-12, is_training=True, freeze_bn=0):
         """init BatchNormGrad layer"""
-        self.is_training = check_bool(is_training)
-        self.freeze_bn = check_int(freeze_bn)
-        self.epsilon = validator.check_float_positive('epsilon', epsilon)
+        self.is_training = validator.check_value_type('is_training', is_training, (bool,), self.name)
+        self.freeze_bn = validator.check_value_type('freeze_bn', freeze_bn, (int,), self.name)
+        self.epsilon = validator.check_float_positive('epsilon', epsilon, self.name)
         self.init_prim_io_names(inputs=['d_batch_mean', 'd_batch_std', 'x', 'batch_mean', 'batch_std', 'global_step'],
                                 outputs=['dx'])
 
     def infer_shape(self, d_batch_mean_shape, d_batch_std_shape, x_shape, batch_mean_shape, batch_std_shape,
                     global_step_shape):
         validator.check("d_batch_mean shape", d_batch_mean_shape,
-                        "d_batch_std shape", d_batch_std_shape)
+                        "d_batch_std shape", d_batch_std_shape, Rel.EQ, self.name)
         validator.check("d_batch_mean shape", d_batch_mean_shape,
-                        "batch_mean shape", batch_mean_shape)
+                        "batch_mean shape", batch_mean_shape, Rel.EQ, self.name)
         validator.check("d_batch_mean shape", d_batch_mean_shape,
-                        "batch_std shape", batch_std_shape)
-        validator.check(
-            "x_shape shape", d_batch_mean_shape[0], "input channel", x_shape[self.channel])
-        validator.check_integer("global_step shape",
-                                len(global_step_shape), 1, Rel.EQ)
+                        "batch_std shape", batch_std_shape, Rel.EQ, self.name)
+        validator.check("d_batch_mean_shape[0]", d_batch_mean_shape[0], "input channel", x_shape[self.channel], Rel.EQ,
+                        self.name)
+        validator.check_integer("global_step rank", len(global_step_shape), 1, Rel.EQ, self.name)
         return x_shape
 
     def infer_dtype(self, d_batch_mean_type, d_batch_std_type, x_type, batch_mean_type, batch_std_type,
                     global_step_type):
-        validator.check("input type", x_type,
-                        "d_batch_mean type", d_batch_mean_type)
-        validator.check("input type", x_type,
-                        "d_batch_std type", d_batch_std_type)
-        validator.check("input type", x_type,
-                        "batch_mean type", batch_mean_type)
-        validator.check("input type", x_type, "batch_std type", batch_std_type)
-        validator.check_typename("input type", x_type,
-                                 (mstype.float16, mstype.float32))
-        validator.check_typename(
-            "global_step type", global_step_type, (mstype.int32,))
+        args = {"input": x_type, "d_batch_mean": d_batch_mean_type, "d_batch_std": d_batch_std_type,
+                "batch_mean": batch_mean_type, "batch_std": batch_std_type}
+        validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
+        validator.check_tensor_type_same({"global_step": global_step_type}, (mstype.int32,), self.name)
         return x_type
 
 
@@ -364,18 +331,14 @@ class CorrectionMul(PrimitiveWithInfer):
                                 outputs=['out'])
 
     def infer_shape(self, x_shape, batch_std_shape, running_std_shape):
-        validator.check("batch_std shape", batch_std_shape,
-                        "running_std shape", running_std_shape)
-        validator.check(
-            "batch_std size", batch_std_shape[0], "x_shape channel size", x_shape[self.channel])
+        validator.check("batch_std shape", batch_std_shape, "running_std shape", running_std_shape, Rel.EQ, self.name)
+        validator.check("batch_std_shape[0]", batch_std_shape[0], "x_shape channel size", x_shape[self.channel],
+                        Rel.EQ, self.name)
         return x_shape
 
     def infer_dtype(self, x_type, batch_std_type, running_std_type):
-        validator.check("batch_std type", batch_std_type,
-                        "running_std type", running_std_type)
-        validator.check("batch_std_type", batch_std_type, "x_type", x_type)
-        validator.check_typename(
-            "batch_std type", batch_std_type, (mstype.float16, mstype.float32))
+        args = {"x": x_type, "batch_std": batch_std_type, "running_std": running_std_type}
+        validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
         return x_type
 
 
@@ -390,20 +353,16 @@ class CorrectionMulGrad(PrimitiveWithInfer):
                                 outputs=['dx', 'd_gamma'])
 
     def infer_shape(self, dout_shape, x_shape, gamma_shape, running_std_shape):
-        validator.check("dout shape", dout_shape, "x_shape x", x_shape)
-        validator.check(
-            "gamma size", gamma_shape[0], "dout channel size", dout_shape[self.channel])
-        validator.check(
-            "running_std size", running_std_shape[0], "dout channel size", dout_shape[self.channel])
+        validator.check("dout shape", dout_shape, "x_shape x", x_shape, Rel.EQ, self.name)
+        validator.check("gamma_shape[0]", gamma_shape[0], "dout channel size", dout_shape[self.channel],
+                        Rel.EQ, self.name)
+        validator.check("running_std_shape[0]", running_std_shape[0], "dout channel size", dout_shape[self.channel],
+                        Rel.EQ, self.name)
         return x_shape, gamma_shape
 
     def infer_dtype(self, dout_type, x_type, gamma_type, running_std_type):
-        validator.check("x type", x_type, "dout type", dout_type)
-        validator.check("gamma type", gamma_type, "dout type", dout_type)
-        validator.check("running_std type", running_std_type,
-                        "dout type", dout_type)
-        validator.check_typename(
-            "dout type", dout_type, (mstype.float16, mstype.float32))
+        args = {"dout": dout_type, "x": x_type, "gamma": gamma_type, "running_std": running_std_type}
+        validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
         return x_type, x_type
 
 
@@ -432,46 +391,29 @@ class BatchNormFold2(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, freeze_bn=0):
         """init conv2d fold layer"""
-        self.freeze_bn = check_int(freeze_bn)
+        self.freeze_bn = validator.check_value_type('freeze_bn', freeze_bn, (int,), self.name)
         self.init_prim_io_names(inputs=['x', 'beta', 'gamma', 'batch_std', 'batch_mean',
                                         'running_std', 'running_mean', 'global_step'],
                                 outputs=['y'])
 
     def infer_shape(self, x_shape, beta_shape, gamma_shape, batch_std_shape, running_std_shape, batch_mean_shape,
                     running_mean_shape, global_step_shape):
-        validator.check("batch_std shape", batch_std_shape,
-                        "running_std shape", running_std_shape)
-        validator.check("batch_std shape", batch_std_shape,
-                        "batch_mean shape", batch_mean_shape)
-        validator.check("batch_std shape", batch_std_shape,
-                        "beta shape", beta_shape)
-        validator.check("batch_std shape", batch_std_shape,
-                        "running_mean shape", running_mean_shape)
-        validator.check("batch_std shape", batch_std_shape,
-                        "batch_mean shape", gamma_shape)
-        validator.check(
-            "batch_std size", batch_std_shape[0], "x_shape channel size", x_shape[self.channel])
-        validator.check_integer("global_step shape",
-                                len(global_step_shape), 1, Rel.EQ)
+        validator.check("batch_std shape", batch_std_shape, "running_std shape", running_std_shape, Rel.EQ, self.name)
+        validator.check("batch_std shape", batch_std_shape, "batch_mean shape", batch_mean_shape, Rel.EQ, self.name)
+        validator.check("batch_std shape", batch_std_shape, "beta shape", beta_shape, Rel.EQ, self.name)
+        validator.check("batch_std shape", batch_std_shape, "running_mean shape", running_mean_shape, Rel.EQ, self.name)
+        validator.check("batch_std shape", batch_std_shape, "batch_mean shape", gamma_shape, Rel.EQ, self.name)
+        validator.check("batch_std_shape[0]", batch_std_shape[0], "x_shape channel size", x_shape[self.channel],
+                        Rel.EQ, self.name)
+        validator.check_integer("global_step rank", len(global_step_shape), 1, Rel.EQ, self.name)
         return x_shape
 
     def infer_dtype(self, x_type, beta_type, gamma_type, batch_std_type, running_std_type, batch_mean_type,
                     running_mean_type, global_step_type):
-        validator.check("batch_std type", batch_std_type,
-                        "running_std type", running_std_type)
-        validator.check("batch_std type", batch_std_type,
-                        "batch_mean type", batch_mean_type)
-        validator.check("batch_std type", batch_std_type,
-                        "beta type", beta_type)
-        validator.check("batch_std type", batch_std_type,
-                        "running_mean type", running_mean_type)
-        validator.check("batch_std type", batch_std_type,
-                        "gamma type", gamma_type)
-        validator.check("x_type", x_type, "batch_std type", batch_std_type)
-        validator.check_typename(
-            "batch_std type", batch_std_type, (mstype.float16, mstype.float32))
-        validator.check_typename(
-            "global_step type", global_step_type, (mstype.int32,))
+        args = {"batch_std": batch_std_type, "running_std": running_std_type, "batch_mean": batch_mean_type,
+                "beta": beta_type, "running_mean": running_mean_type, "gamma": gamma_type, "x": x_type}
+        validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
+        validator.check_tensor_type_same({"global_step": global_step_type}, (mstype.int32,), self.name)
         return x_type
 
 
@@ -491,18 +433,13 @@ class BatchNormFold2Grad(PrimitiveWithInfer):
     def infer_shape(self, dout_shape, x_shape, gamma_shape,
                     batch_std_shape, batch_mean_shape,
                     running_std_shape, running_mean_shape, global_step_shape):
-        validator.check("batch_std shape", batch_std_shape,
-                        "batch_mean shape", batch_mean_shape)
-        validator.check("batch_std shape", batch_std_shape,
-                        "running_std shape", running_std_shape)
-        validator.check("batch_std shape", batch_std_shape,
-                        "running_mean shape", running_mean_shape)
-        validator.check("batch_std shape", batch_std_shape,
-                        "gamma shape", gamma_shape)
-        validator.check(
-            "batch_std size", batch_std_shape[0], "dout channel size", dout_shape[self.channel])
-        validator.check_integer("global_step shape",
-                                len(global_step_shape), 1, Rel.EQ)
+        validator.check("batch_std shape", batch_std_shape, "batch_mean shape", batch_mean_shape, Rel.EQ, self.name)
+        validator.check("batch_std shape", batch_std_shape, "running_std shape", running_std_shape, Rel.EQ, self.name)
+        validator.check("batch_std shape", batch_std_shape, "running_mean shape", running_mean_shape, Rel.EQ, self.name)
+        validator.check("batch_std shape", batch_std_shape, "gamma shape", gamma_shape, Rel.EQ, self.name)
+        validator.check("batch_std size", batch_std_shape[0], "dout channel size", dout_shape[self.channel],
+                        Rel.EQ, self.name)
+        validator.check_integer("global_step rank", len(global_step_shape), 1, Rel.EQ, self.name)
         return gamma_shape, gamma_shape, gamma_shape, gamma_shape, x_shape
 
     def infer_dtype(self, dout_type, x_type, gamma_type,
@@ -518,8 +455,8 @@ class BatchNormFold2Grad(PrimitiveWithInfer):
                         "running_mean type", running_mean_type)
         validator.check("batch_std_type", batch_std_type,
                         "dout type", dout_type)
-        validator.check_typename(
-            "batch_std type", batch_std_type, (mstype.float16, mstype.float32))
-        validator.check_typename(
-            "global_step type", global_step_type, (mstype.int32,))
+        args = {"batch_std": batch_std_type, "batch_mean": batch_mean_type, "gamma": gamma_type,
+                "running_std": running_std_type, "running_mean": running_mean_type, "dout": dout_type}
+        validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
+        validator.check_tensor_type_same({"global_step": global_step_type}, (mstype.int32,), self.name)
         return gamma_type, gamma_type, gamma_type, gamma_type, gamma_type

mindspore/ops/operations/comm_ops.py

@@ -15,7 +15,8 @@
 
 """comm_ops"""
 
-from ..._checkparam import ParamValidator as validator
+from ..._checkparam import Validator as validator
+from ..._checkparam import Rel
 from ...communication.management import get_rank, get_group_size, GlobalComm, get_group
 from ...common import dtype as mstype
 from ..primitive import PrimitiveWithInfer, prim_attr_register
@@ -148,12 +149,10 @@ class AllGather(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, group=GlobalComm.WORLD_COMM_GROUP):
-        if not isinstance(get_group(group), str):
-            raise TypeError("The group of AllGather should be str.")
+        validator.check_value_type('group', get_group(group), (str,), self.name)
         self.rank = get_rank(get_group(group))
         self.rank_size = get_group_size(get_group(group))
-        if self.rank >= self.rank_size:
-            raise ValueError("The rank of AllGather should be less than the rank_size.")
+        validator.check('rank', self.rank, 'rank_size', self.rank_size, Rel.LT, self.name)
         self.add_prim_attr('rank_size', self.rank_size)
         self.add_prim_attr('group', get_group(group))
 
@@ -163,7 +162,7 @@ class AllGather(PrimitiveWithInfer):
 
     def infer_dtype(self, x_dtype):
         if x_dtype == mstype.bool_:
-            raise TypeError("AllGather does not support 'Bool' as the dtype of input!")
+            raise TypeError(f"{self.name} does not support 'Bool' as the dtype of input!")
         return x_dtype
 
     def __call__(self, tensor):
@@ -205,10 +204,8 @@ class ReduceScatter(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, op=ReduceOp.SUM, group=GlobalComm.WORLD_COMM_GROUP):
-        if not isinstance(op, type(ReduceOp.SUM)):
-            raise TypeError("The operation of ReduceScatter should be {}.".format(type(ReduceOp.SUM)))
-        if not isinstance(get_group(group), str):
-            raise TypeError("The group of ReduceScatter should be str.")
+        validator.check_value_type('op', op, (type(ReduceOp.SUM),), self.name)
+        validator.check_value_type('group', get_group(group), (str,), self.name)
         self.op = op
         self.rank_size = get_group_size(get_group(group))
         self.add_prim_attr('rank_size', self.rank_size)
@@ -216,13 +213,13 @@ class ReduceScatter(PrimitiveWithInfer):
 
     def infer_shape(self, x_shape):
         if x_shape[0] % self.rank_size != 0:
-            raise ValueError("The first dimension of x should be divided by rank_size.")
+            raise ValueError(f"For '{self.name}' the first dimension of x should be divided by rank_size.")
         x_shape[0] = int(x_shape[0]/self.rank_size)
         return x_shape
 
     def infer_dtype(self, x_dtype):
         if x_dtype == mstype.bool_:
-            raise TypeError("ReduceScatter does not support 'Bool' as the dtype of input!")
+            raise TypeError(f"{self.name} does not support 'Bool' as the dtype of input!")
         return x_dtype
 
     def __call__(self, tensor):
@@ -270,10 +267,8 @@ class Broadcast(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, root_rank, group=GlobalComm.WORLD_COMM_GROUP):
-        if not isinstance(root_rank, int):
-            raise TypeError("The root_rank of Broadcast should be int.")
-        if not isinstance(get_group(group), str):
-            raise TypeError("The group of Broadcast should be str.")
+        validator.check_value_type('root_rank', root_rank, (int,), self.name)
+        validator.check_value_type('group', get_group(group), (str,), self.name)
         self.add_prim_attr('group', get_group(group))
 
     def infer_shape(self, x_shape):
@@ -281,7 +276,7 @@ class Broadcast(PrimitiveWithInfer):
 
     def infer_dtype(self, x_dtype):
         if x_dtype == mstype.bool_:
-            raise TypeError("Broadcast does not support 'Bool' as the dtype of input!")
+            raise TypeError(f"{self.name} does not support 'Bool' as the dtype of input!")
         return x_dtype
 
 
@@ -311,8 +306,7 @@ class _AlltoAll(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, split_count, split_dim, concat_dim, group=GlobalComm.WORLD_COMM_GROUP):
         """init AlltoAll"""
-        if not isinstance(get_group(group), str):
-            raise TypeError("The group of AllGather should be str.")
+        validator.check_value_type('group', get_group(group), (str,), self.name)
         self.split_count = split_count
         self.split_dim = split_dim
         self.concat_dim = concat_dim
@@ -325,7 +319,7 @@ class _AlltoAll(PrimitiveWithInfer):
 
     def infer_dtype(self, x_dtype):
         if x_dtype == mstype.bool_:
-            raise TypeError("AlltoAll does not support 'Bool' as the dtype of input!")
+            raise TypeError(f"{self.name} does not support 'Bool' as the dtype of input!")
         return x_dtype
 
     def __call__(self, tensor):
@@ -420,6 +414,6 @@ class _GetTensorSlice(PrimitiveWithInfer):
 
     def infer_value(self, x, dev_mat, tensor_map):
         from mindspore.parallel._tensor import _load_tensor
-        validator.check_type("dev_mat", dev_mat, [tuple])
-        validator.check_type("tensor_map", tensor_map, [tuple])
+        validator.check_value_type("dev_mat", dev_mat, [tuple], self.name)
+        validator.check_value_type("tensor_map", tensor_map, [tuple], self.name)
         return _load_tensor(x, dev_mat, tensor_map)

mindspore/ops/operations/control_ops.py

@@ -16,7 +16,8 @@
 """control_ops"""
 
 from ...common import dtype as mstype
-from ..._checkparam import ParamValidator as validator
+from ..._checkparam import Validator as validator
+from ..._checkparam import Rel
 from ..primitive import Primitive, PrimitiveWithInfer, prim_attr_register
 
 
@@ -123,11 +124,11 @@ class GeSwitch(PrimitiveWithInfer):
         raise NotImplementedError
 
     def infer_shape(self, data, pred):
-        validator.check_scalar_shape_input("pred", pred)
+        validator.check_integer("pred rank", len(pred), 0, Rel.EQ, self.name)
         return (data, data)
 
     def infer_dtype(self, data_type, pred_type):
-        validator.check_type("pred", pred_type, [type(mstype.bool_)])
+        validator.check_tensor_type_same({"pred": pred_type}, [mstype.bool_], self.name)
         return (data_type, data_type)
 
 

mindspore/ops/operations/debug_ops.py

@@ -14,7 +14,7 @@
 # ============================================================================
 
 """debug_ops"""
-from ..._checkparam import ParamValidator as validator
+from ..._checkparam import Validator as validator
 from ...common import dtype as mstype
 from ..primitive import Primitive, prim_attr_register, PrimitiveWithInfer
 
@@ -219,5 +219,5 @@ class Print(PrimitiveWithInfer):
 
     def infer_dtype(self, *inputs):
         for dtype in inputs:
-            validator.check_subclass("input", dtype, (mstype.tensor, mstype.string))
+            validator.check_subclass("input", dtype, (mstype.tensor, mstype.string), self.name)
         return mstype.int32

mindspore/ops/operations/other_ops.py

@@ -16,7 +16,7 @@
 """Other operators."""
 from ..._c_expression import signature_rw as sig_rw
 from ..._c_expression import signature_kind as sig_kind
-from ..._checkparam import ParamValidator as validator, Rel
+from ..._checkparam import Validator as validator, Rel
 from ...common import dtype as mstype
 from ..primitive import Primitive, PrimitiveWithInfer, prim_attr_register
 
@@ -82,22 +82,21 @@ class BoundingBoxEncode(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0)):
-        validator.check_type('means', means, [tuple])
-        validator.check_type('stds', stds, [tuple])
-        validator.check("means len", len(means), '', 4)
-        validator.check("stds len", len(stds), '', 4)
+        validator.check_value_type('means', means, [tuple], self.name)
+        validator.check_value_type('stds', stds, [tuple], self.name)
+        validator.check_integer("means len", len(means), 4, Rel.EQ, self.name)
+        validator.check_integer("stds len", len(stds), 4, Rel.EQ, self.name)
 
     def infer_shape(self, anchor_box, groundtruth_box):
-        validator.check('anchor_box shape[0]', anchor_box[0], 'groundtruth_box shape[0]', groundtruth_box[0])
-        validator.check('anchor_box shape[1]', anchor_box[1], '', 4)
-        validator.check('groundtruth_box shape[1]', groundtruth_box[1], '', 4)
+        validator.check('anchor_box shape[0]', anchor_box[0], 'groundtruth_box shape[0]', groundtruth_box[0], Rel.EQ,
+                        self.name)
+        validator.check_integer('anchor_box shape[1]', anchor_box[1], 4, Rel.EQ, self.name)
+        validator.check_integer('groundtruth_box shape[1]', groundtruth_box[1], 4, Rel.EQ, self.name)
         return anchor_box
 
     def infer_dtype(self, anchor_box, groundtruth_box):
-        args = {"anchor_box": anchor_box,
-                "groundtruth_box": groundtruth_box
-                }
-        validator.check_type_same(args, mstype.number_type)
+        args = {"anchor_box": anchor_box, "groundtruth_box": groundtruth_box}
+        validator.check_tensor_type_same(args, mstype.number_type, self.name)
         return anchor_box
 
 
@@ -126,26 +125,24 @@ class BoundingBoxDecode(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, max_shape, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0), wh_ratio_clip=0.016):
-        validator.check_type('means', means, [tuple])
-        validator.check_type('stds', stds, [tuple])
-        validator.check_type('wh_ratio_clip', wh_ratio_clip, [float])
-        validator.check("means", len(means), '', 4)
-        validator.check("stds", len(stds), '', 4)
+        validator.check_value_type('means', means, [tuple], self.name)
+        validator.check_value_type('stds', stds, [tuple], self.name)
+        validator.check_value_type('wh_ratio_clip', wh_ratio_clip, [float], self.name)
+        validator.check_integer("means len", len(means), 4, Rel.EQ, self.name)
+        validator.check_integer("stds len", len(stds), 4, Rel.EQ, self.name)
         if max_shape is not None:
-            validator.check_type('max_shape', max_shape, [tuple])
-            validator.check("max_shape", len(max_shape), '', 2)
+            validator.check_value_type('max_shape', max_shape, [tuple], self.name)
+            validator.check_integer("max_shape len", len(max_shape), 2, Rel.EQ, self.name)
 
     def infer_shape(self, anchor_box, deltas):
-        validator.check('anchor_box shape[0]', anchor_box[0], 'deltas shape[0]', deltas[0])
-        validator.check('anchor_box shape[1]', anchor_box[1], '', 4)
-        validator.check('deltas shape[1]', deltas[1], '', 4)
+        validator.check('anchor_box shape[0]', anchor_box[0], 'deltas shape[0]', deltas[0], Rel.EQ, self.name)
+        validator.check_integer('anchor_box shape[1]', anchor_box[1], 4, Rel.EQ, self.name)
+        validator.check_integer('deltas shape[1]', deltas[1], 4, Rel.EQ, self.name)
         return anchor_box
 
     def infer_dtype(self, anchor_box, deltas):
-        args = {"anchor_box": anchor_box,
-                "deltas": deltas
-                }
-        validator.check_type_same(args, mstype.number_type)
+        args = {"anchor_box": anchor_box, "deltas": deltas}
+        validator.check_tensor_type_same(args, mstype.number_type, self.name)
         return anchor_box
 
 
@@ -168,10 +165,10 @@ class CheckValid(PrimitiveWithInfer):
         self.init_prim_io_names(inputs=['bboxes', 'img_metas'], outputs=['output'])
 
     def infer_shape(self, bboxes_shape, metas_shape):
-        validator.check_shape_length("bboxes shape length", len(bboxes_shape), 2, Rel.EQ)
-        validator.check("bboxes_shape[-1]", bboxes_shape[-1], "", 4, Rel.EQ)
-        validator.check_shape_length("img_metas shape length", len(metas_shape), 1, Rel.EQ)
-        validator.check("img_metas shape[0]", metas_shape[0], "", 3, Rel.EQ)
+        validator.check_integer("bboxes rank", len(bboxes_shape), 2, Rel.EQ, self.name)
+        validator.check_integer("bboxes_shape[-1]", bboxes_shape[-1], 4, Rel.EQ, self.name)
+        validator.check_integer("img_metas rank", len(metas_shape), 1, Rel.EQ, self.name)
+        validator.check_integer("img_metas shape[0]", metas_shape[0], 3, Rel.EQ, self.name)
         return bboxes_shape[:-1]
 
     def infer_dtype(self, bboxes_type, metas_type):
@@ -221,18 +218,16 @@ class IOU(PrimitiveWithInfer):
         self.init_prim_io_names(inputs=['anchor_boxes', 'gt_boxes'], outputs=['overlap'])
 
     def infer_shape(self, anchor_boxes, gt_boxes):
-        validator.check('gt_boxes shape[1]', gt_boxes[1], '', 4)
-        validator.check('anchor_boxes shape[1]', anchor_boxes[1], '', 4)
-        validator.check('anchor_boxes rank', len(anchor_boxes), '', 2)
-        validator.check('gt_boxes rank', len(gt_boxes), '', 2)
+        validator.check_integer('gt_boxes shape[1]', gt_boxes[1], 4, Rel.EQ, self.name)
+        validator.check_integer('anchor_boxes shape[1]', anchor_boxes[1], 4, Rel.EQ, self.name)
+        validator.check_integer('anchor_boxes rank', len(anchor_boxes), 2, Rel.EQ, self.name)
+        validator.check_integer('gt_boxes rank', len(gt_boxes), 2, Rel.EQ, self.name)
         iou = [gt_boxes[0], anchor_boxes[0]]
         return iou
 
     def infer_dtype(self, anchor_boxes, gt_boxes):
-        validator.check_subclass("anchor_boxes", anchor_boxes, mstype.tensor)
-        validator.check_subclass("gt_boxes", gt_boxes, mstype.tensor)
         args = {"anchor_boxes": anchor_boxes, "gt_boxes": gt_boxes}
-        validator.check_type_same(args, (mstype.float16,))
+        validator.check_tensor_type_same(args, (mstype.float16,), self.name)
         return anchor_boxes
 
 
@@ -270,7 +265,7 @@ class MakeRefKey(Primitive):
 
     @prim_attr_register
     def __init__(self, tag):
-        validator.check_type('tag', tag, (str,))
+        validator.check_value_type('tag', tag, (str,), self.name)
 
     def __call__(self):
         pass

mindspore/ops/operations/random_ops.py

@@ -15,7 +15,7 @@
 
 """Operators for random."""
 
-from ..._checkparam import ParamValidator as validator
+from ..._checkparam import Validator as validator
 from ..._checkparam import Rel
 from ...common import dtype as mstype
 from ..primitive import PrimitiveWithInfer, prim_attr_register
@@ -52,16 +52,15 @@ class RandomChoiceWithMask(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, count=256, seed=0, seed2=0):
         """Init RandomChoiceWithMask"""
-        validator.check_type("count", count, [int])
-        validator.check_integer("count", count, 0, Rel.GT)
-        validator.check_type('seed', seed, [int])
-        validator.check_type('seed2', seed2, [int])
+        validator.check_value_type("count", count, [int], self.name)
+        validator.check_integer("count", count, 0, Rel.GT, self.name)
+        validator.check_value_type('seed', seed, [int], self.name)
+        validator.check_value_type('seed2', seed2, [int], self.name)
 
     def infer_shape(self, x_shape):
-        validator.check_shape_length("input_x shape", len(x_shape), 1, Rel.GE)
+        validator.check_integer("input_x rank", len(x_shape), 1, Rel.GE, self.name)
         return ([self.count, len(x_shape)], [self.count])
 
     def infer_dtype(self, x_dtype):
-        validator.check_subclass('x_dtype', x_dtype, mstype.tensor)
-        validator.check_typename('x_dtype', x_dtype, [mstype.bool_])
+        validator.check_tensor_type_same({'x': x_dtype}, [mstype.bool_], self.name)
         return (mstype.int32, mstype.bool_)