Modify error content

mindspore/nn/layer/activation.py

@@ -593,20 +593,24 @@ class PReLU(Cell):
             w = Tensor(tmp, dtype=mstype.float32)
         elif isinstance(w, list):
             if len(w) != channel:
-                raise ValueError(f"When the 'w' is a list, the length should be equal to the channel, "
-                                 f"but got the length  {len(w)}, the channel {channel}")
+                raise ValueError(f"For '{self.cls_name}', the length of 'w' should be equal to the 'channel' when "
+                                 f"the 'w' is a list, but got the length of 'w': {len(w)}, the 'channel': {channel}.")
+
             for i in w:
                 if not isinstance(i, (float, np.float32)):
-                    raise ValueError(f"When the 'w' is a list, the all elements should be float, but got {w}")
+                    raise ValueError(f"For '{self.cls_name}', all elements in 'w' should be "
+                                     f"float when the 'w' is a list, but got {i}.")
             w = Tensor(w, dtype=mstype.float32)
         elif isinstance(w, Tensor):
             if w.dtype not in (mstype.float16, mstype.float32):
-                raise ValueError(f"When the 'w' is a tensor, the dtype should be float16 or float32, but got {w.dtype}")
+                raise ValueError(f"For '{self.cls_name}', the dtype of 'w' should be float16 or "
+                                 f"float32 when the 'w' is a tensor, but got {w.dtype}.")
             if len(w.shape) != 1 or w.shape[0] != channel:
-                raise ValueError(f"When the 'w' is a tensor, the rank should be 1, and the elements number "
-                                 f"should be equal to the channel, but got w shape {w}, the channel {channel}")
+                raise ValueError(f"For '{self.cls_name}', the dimension of 'w' should be 1, and the elements number "
+                                 f"should be equal to the 'channel' when the 'w' is a tensor, but got 'w' shape {w}, "
+                                 f"the 'channel' {channel}.")
         else:
-            raise TypeError(f"The 'w' only supported float list and tensor, but got {type(w)}")
+            raise TypeError(f"For '{self.cls_name}', the 'w' only supported float, list and tensor, but got {type(w)}.")
         self.w = Parameter(w, name='a')
         self.prelu = P.PReLU()
         self.relu = P.ReLU()
@@ -870,7 +874,7 @@ _activation = {
 }
 
 
-def get_activation(name):
+def get_activation(name, prim_name=None):
     """
     Gets the activation function.
 
@@ -888,9 +892,11 @@ def get_activation(name):
         >>> print(sigmoid)
         Sigmoid<>
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if name is None:
         return None
 
     if name not in _activation:
-        raise KeyError(f"Unknown activation type '{name}'")
+        raise KeyError(f"{msg_prefix} 'name' should be in {_activation}, but got '{name}'. "
+                       f"Refer to official documents for more information.")
     return _activation[name]()

mindspore/nn/layer/basic.py

@@ -81,9 +81,9 @@ class L1Regularizer(Cell):
         super(L1Regularizer, self).__init__()
         Validator.check_value_type("scale", scale, [int, float], self.cls_name)
         if scale <= 0:
-            raise ValueError("scale should be a number which greater than 0")
+            raise ValueError(f"For '{self.cls_name}', the 'scale' should be greater than 0, but got {scale}.")
         if math.isinf(scale) or math.isnan(scale):
-            raise ValueError("scale can not be INF or NAN")
+            raise ValueError(f"For '{self.cls_name}', the 'scale' can not be INF or NAN, but got {scale}.")
         self.abs = P.Abs()
         self.reduce_sum = P.ReduceSum()
         self.scale = Tensor(scale, dtype=mstype.float32)
@@ -149,7 +149,8 @@ class Dropout(Cell):
         """Initialize Dropout."""
         super(Dropout, self).__init__()
         if keep_prob <= 0 or keep_prob > 1:
-            raise ValueError("dropout probability should be a number in range (0, 1], but got {}".format(keep_prob))
+            raise ValueError(f"For '{self.cls_name}', the 'keep_prob' should be a number in range (0, 1], "
+                             f"but got {keep_prob}.")
         Validator.check_subclass("dtype", dtype, mstype.number_type, self.cls_name)
         Validator.check_value_type('keep_prob', keep_prob, [float], self.cls_name)
         self.keep_prob = keep_prob
@@ -215,10 +216,10 @@ class Flatten(Cell):
 
 
 @constexpr
-def check_dense_input_shape(x):
+def check_dense_input_shape(x, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(x) < 2:
-        raise ValueError('For Dense, the dimension of input should not be less than 2, while the input dimension is '
-                         + f'{len(x)}.')
+        raise ValueError(f"{msg_prefix} dimension of 'x' should not be less than 2, but got {len(x)}.")
 
 
 class Dense(Cell):
@@ -292,26 +293,32 @@ class Dense(Cell):
         if isinstance(weight_init, Tensor):
             if weight_init.ndim != 2 or weight_init.shape[0] != out_channels or \
                     weight_init.shape[1] != in_channels:
-                raise ValueError("Weight init shape error.")
+                raise ValueError(f"For '{self.cls_name}', weight init shape error. The ndim of 'weight_init' should "
+                                 f"be equal to 2, and the first dim should be equal to 'out_channels', and the "
+                                 f"second dim should be equal to 'in_channels'. But got 'weight_init': {weight_init}, "
+                                 f"'out_channels': {out_channels}, 'in_channels': {in_channels}.")
         self.weight = Parameter(initializer(weight_init, [out_channels, in_channels]), name="weight")
 
         self.bias = None
         if self.has_bias:
             if isinstance(bias_init, Tensor):
                 if bias_init.ndim != 1 or bias_init.shape[0] != out_channels:
-                    raise ValueError("Bias init shape error.")
+                    raise ValueError(f"For '{self.cls_name}', bias init shape error. The ndim of 'bias_init' should "
+                                     f"be equal to 1, and the first dim should be equal to 'out_channels'. But got "
+                                     f"'bias_init': {bias_init}, 'out_channels': {out_channels}.")
             self.bias = Parameter(initializer(bias_init, [out_channels]), name="bias")
             self.bias_add = P.BiasAdd()
 
         self.matmul = P.MatMul(transpose_b=True)
         self.activation = get_activation(activation) if isinstance(activation, str) else activation
         if activation is not None and not isinstance(self.activation, (Cell, Primitive)):
-            raise TypeError("The activation must be str or Cell or Primitive,"" but got {}.".format(activation))
+            raise TypeError(f"For '{self.cls_name}', the 'activation' must be str or Cell or Primitive, but got "
+                            f"{type(activation)}.")
         self.activation_flag = self.activation is not None
 
     def construct(self, x):
         x_shape = self.shape_op(x)
-        check_dense_input_shape(x_shape)
+        check_dense_input_shape(x_shape, self.cls_name)
         if len(x_shape) != 2:
             x = self.reshape(x, (-1, x_shape[-1]))
         x = self.matmul(x, self.weight)
@@ -341,9 +348,10 @@ def _is_equal_one(x):
 
 
 @constexpr
-def _dtype_check(x_dtype):
+def _dtype_check(x_dtype, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if x_dtype not in [mstype.float32, mstype.float16]:
-        raise TypeError("The input type must be float32 or float16.")
+        raise TypeError(f"{msg_prefix} x_dtype must be float32 or float16, but got {x_dtype}.")
 
 
 @constexpr
@@ -430,7 +438,7 @@ class ClipByNorm(Cell):
         l2sum_safe = self.select_(cond, l2sum, self.cast(ones_, self.dtype(l2sum)))
         l2norm = self.select_(cond, self.sqrt(l2sum_safe), l2sum)
 
-        _dtype_check(self.dtype(x))
+        _dtype_check(self.dtype(x), self.cls_name)
         if _is_equal_one(clip_norm):
             intermediate = x
         else:
@@ -792,12 +800,14 @@ class Pad(Cell):
         self.paddings = paddings
         Validator.check_string(self.mode, ["CONSTANT", "REFLECT", "SYMMETRIC"], 'mode', self.cls_name)
         if not isinstance(paddings, tuple):
-            raise TypeError('Paddings must be tuple type.')
+            raise TypeError(f"For '{self.cls_name}', the type of 'paddings' must be tuple, but got {type(paddings)}.")
         for item in paddings:
             if len(item) != 2:
-                raise ValueError('The shape of paddings must be (n, 2).')
+                raise ValueError(f"For '{self.cls_name}', the dimension of 'paddings' must be (n, 2), "
+                                 f"but got {paddings}.")
         if len(paddings) > 4:
-            raise ValueError('Only padding up to 4 dims is supported')
+            raise ValueError(f"For '{self.cls_name}', only 'paddings' up to 4 dims is supported, but got "
+                             f"{len(paddings)}.")
         if mode == "CONSTANT":
             self.pad = P.Pad(self.paddings)
         else:
@@ -813,17 +823,18 @@ class Pad(Cell):
 
 
 @constexpr
-def bilinear(shape, size, scale, align_corners):
+def bilinear(shape, size, scale, align_corners, prim_name=None):
     """Check input and calculate shape"""
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if not isinstance(align_corners, bool):
-        raise TypeError("align_corners should be type boolean")
+        raise TypeError(f"{msg_prefix} type of 'align_corners' should be boolean, but got {type(align_corners)}.")
     if size is None and scale is None:
-        raise ValueError("size and scale both none")
+        raise ValueError(f"{msg_prefix} 'size' and 'scale' both none.")
     if size is not None and scale is not None:
-        raise ValueError("size and scale both not none")
+        raise ValueError(f"{msg_prefix} 'size' and 'scale' both not none.")
     if size is not None:
         if not isinstance(size, (tuple, list)):
-            raise ValueError("size must be tuple or list")
+            raise ValueError(f"{msg_prefix} 'size' must be tuple or list, but got {type(size)}.")
         Validator.check_int(len(size), 2, Rel.EQ, "size", "bilinear")
         Validator.check_int(size[0], 1, Rel.GE, "size[0]", "bilinear")
         Validator.check_int(size[1], 1, Rel.GE, "size[1]", "bilinear")
@@ -958,7 +969,7 @@ class Unfold(Cell):
         def _check_tuple_or_list(arg_name, arg_val, prim_name):
             Validator.check_value_type(f"{arg_name}s", ksizes, [tuple, list], self.cls_name)
             if len(arg_val) != 4 or arg_val[0] != 1 or arg_val[3] != 1:
-                raise ValueError(f"For \'{prim_name}\' the format of {arg_name}s should be [1, {arg_name}_row, "
+                raise ValueError(f"For '{prim_name}' the format of {arg_name}s should be [1, {arg_name}_row, "
                                  f"{arg_name}_col, 1], but got {arg_val}.")
             if not isinstance(arg_val[1], int) or not isinstance(arg_val[2], int) or arg_val[1] < 1 or arg_val[2] < 1:
                 raise ValueError(f"For '{prim_name}' the {arg_name}_row and {arg_name}_col in {arg_name}s should be "
@@ -1422,7 +1433,9 @@ class Roll(Cell):
             self.op_list.append((inner.Roll(shift=self.shift, axis=0), self.axis))
         else:
             if len(self.shift) != len(self.axis):
-                raise ValueError('The shape of shift and the shape of axis must be the same.')
+                raise ValueError(f"For '{self.cls_name}', the shape of 'shift' and the shape of 'axis' must be "
+                                 f"the same, but got the length of 'shift' {len(self.shift)} and the length of 'axis'"
+                                 f" {len(self.axis)}.")
             for idx, _ in enumerate(self.axis):
                 self.op_list.append((inner.Roll(shift=self.shift[idx], axis=0), self.axis[idx]))
 

mindspore/nn/layer/lstm.py

@@ -46,7 +46,8 @@ def _check_input_dtype(input_dtype, param_name, allow_dtypes, cls_name):
 @constexpr
 def _check_input_3d(input_shape, param_name, func_name):
     if len(input_shape) != 3:
-        raise ValueError(f"{func_name} {param_name} should be 3d, but got shape {input_shape}")
+        raise ValueError(f"For '{func_name}', the {param_name} should be 3d, but got the length of input_shape:"
+                         f" {len(input_shape)}.")
 
 
 class LSTM(Cell):
@@ -166,7 +167,8 @@ class LSTM(Cell):
             self.cast = P.Cast()
             self.shape = P.Shape()
             if dropout < 0 or dropout > 1:
-                raise ValueError("For LSTM, dropout must be a number in range [0, 1], but got {}".format(dropout))
+                raise ValueError(f"For '{self.cls_name}', the 'dropout' must be a number in range [0, 1], "
+                                 f"but got {dropout}.")
             if dropout == 1:
                 self.dropout_op = P.ZerosLike()
             else:

mindspore/nn/layer/math.py

@@ -148,7 +148,7 @@ class Range(Cell):
         """Initialize Range."""
         super(Range, self).__init__()
         if delta == 0:
-            raise ValueError("The input of `delta` can not be equal to zero.")
+            raise ValueError(f"For '{self.cls_name}', the 'delta' can not be zero.")
         data = np.arange(start, limit, delta)
         if data.dtype == np.float:
             self.ms_dtype = mstype.float32
@@ -750,11 +750,13 @@ class LBeta(Cell):
 
 
 @constexpr
-def get_broadcast_matmul_shape(x_shape, y_shape):
+def get_broadcast_matmul_shape(x_shape, y_shape, prim_name=None):
     """get broadcast_matmul shape"""
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if (len(x_shape) < 2) or (len(y_shape) < 2):
-        raise ValueError('For matmul, rank of x1 and x2 should be equal to or greater than 2, '
-                         + f'but got {x_shape} and {y_shape}.')
+        raise ValueError(f"{msg_prefix} length of 'x_shape' and 'y_shape' should be equal to or greater than 2, "
+                         f"but got the length of 'x_shape': {len(x_shape)} and the length of 'y_shape': "
+                         f"{len(y_shape)}.")
     x_shape_batch = x_shape[:-2]
     y_shape_batch = y_shape[:-2]
     if x_shape_batch == y_shape_batch:
@@ -771,7 +773,9 @@ def get_broadcast_matmul_shape(x_shape, y_shape):
         elif x_shape[i] == y_shape[i]:
             broadcast_shape_back.append(x_shape[i])
         else:
-            raise ValueError(f"For MatMul, the x1_shape {x_shape} and x2_shape {y_shape} can not broadcast.")
+            raise ValueError(f"{msg_prefix} 'x_shape[{i}]' should be equal to 1, or the 'y_shape[{i}]' should be equal "
+                             f"to 1, or the 'x_shape[{i}]' should be equal to 'y_shape[{i}]', but got "
+                             f"'x_shape[{i}]': {x_shape[i]}, 'y_shape[{i}]': {y_shape[i]}.")
 
     broadcast_shape_front = y_shape[0: y_len - length] if length == x_len else x_shape[0: x_len - length]
     x_broadcast_shape = broadcast_shape_front + tuple(broadcast_shape_back) + x_shape[-2:]
@@ -780,8 +784,9 @@ def get_broadcast_matmul_shape(x_shape, y_shape):
 
 
 @constexpr
-def check_col_row_equal(x1_shape, x2_shape, transpose_x1, transpose_x2):
+def check_col_row_equal(x1_shape, x2_shape, transpose_x1, transpose_x2, prim_name=None):
     """check col and row equal"""
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(x1_shape) == 1:
         transpose_x1 = False
         x1_shape = (1,) + x1_shape
@@ -793,8 +798,8 @@ def check_col_row_equal(x1_shape, x2_shape, transpose_x1, transpose_x2):
     x1_col = x1_last[not transpose_x1]  # x1_col = x1_last[1] if (not transpose_a) else x1_last[0]
     x2_row = x2_last[transpose_x2]  # x2_row = x2_last[0] if (not transpose_b) else x2_last[1]
     if x1_col != x2_row:
-        raise ValueError('The column of matrix dimensions of x1 should be equal to '
-                         + f'the row of matrix dimensions of x2, but got {x1_col} and {x2_row}.')
+        raise ValueError(f"{msg_prefix} column of matrix dimensions of 'x1' should be equal to "
+                         f"the row of matrix dimensions of 'x2', but got 'x1_col' {x1_col} and 'x2_row' {x2_row}.")
 
 
 def matmul_op_select(x1_shape, x2_shape, transpose_x1, transpose_x2):

mindspore/nn/layer/normalization.py

@@ -62,17 +62,20 @@ class _BatchNorm(Cell):
         super(_BatchNorm, self).__init__()
         validator.check_value_type('num_features', num_features, [int], self.cls_name)
         if num_features < 1:
-            raise ValueError("num_features must be at least 1")
+            raise ValueError(f"For '{self.cls_name}', the 'num_features' must be at least 1, but got {num_features}.")
 
         if momentum < 0 or momentum > 1:
-            raise ValueError("momentum should be a number in range [0, 1], but got {}".format(momentum))
+            raise ValueError(f"For '{self.cls_name}', the 'momentum' should be a number in range [0, 1], "
+                             f"but got {momentum}.")
         self.input_dims = input_dims
         self.format = validator.check_string(data_format, ['NCHW', 'NHWC'], 'format', self.cls_name)
         if context.get_context("device_target") != "GPU" and self.format == "NHWC":
-            raise ValueError("NHWC format only support in GPU target.")
+            raise ValueError(f"For '{self.cls_name}', the 'NHWC' format only support in GPU target, but got device "
+                             f"target {context.get_context('device_target')}.")
         self.use_batch_statistics = use_batch_statistics
         if self.use_batch_statistics is not None and not isinstance(self.use_batch_statistics, bool):
-            raise ValueError("use_batch_statistics should be a boolean value or None.")
+            raise ValueError(f"For '{self.cls_name}', the 'use_batch_statistics' should be a boolean value or None,"
+                             f" but got {use_batch_statistics}.")
         self.num_features = num_features
         self.eps = eps
         self.moving_mean = Parameter(initializer(
@@ -159,11 +162,14 @@ class _BatchNorm(Cell):
         raise NotImplementedError
 
     def list_group(self, world_rank, group_size):
+        """ Check whether world_rank and group_size  are valid. """
         if group_size > get_group_size():
-            raise ValueError("group size can not be greater than local rank size, group size is {}, "
-                             "local_rank_size is {}".format(group_size, get_group_size()))
+            raise ValueError(f"For '{self.cls_name}', the 'group_size' cannot be greater than local rank size, "
+                             f"but got 'group_size': {group_size}, local rank size: {get_group_size()}.")
         if len(world_rank) % group_size != 0:
-            raise ValueError("please make your group size correct.")
+            raise ValueError(f"For '{self.cls_name}', the dimension of 'world_rank' should be divisible by "
+                             f"'group_size', but got the length of 'world_rank': {len(world_rank)}, "
+                             f"'group_size': {group_size}.")
         world_rank_list = zip(*(iter(world_rank),) * group_size)
         group_list = [list(i) for i in world_rank_list]
         return group_list
@@ -173,7 +179,8 @@ class _BatchNorm(Cell):
         for rid in itertools.chain(*process_groups):
             validator.check_int_range(rid, 0, rank_size, Rel.INC_LEFT, "rank id in process_groups")
             if rid in seen:
-                raise ValueError("rank id in process_groups should not be duplicated.")
+                raise ValueError(f"For '{self.cls_name}', rank id in 'process_groups' should not be duplicated, "
+                                 f"but got {rid}.")
             seen.add(rid)
 
     def _create_global_groups(self):
@@ -197,7 +204,7 @@ class _BatchNorm(Cell):
                     management.create_group(SYNC_BN_GROUP_NAME, self.process_groups[i])
 
     def construct(self, x):
-        _shape_check_bn(self.shape(x), self.input_dims)
+        _shape_check_bn(self.shape(x), self.input_dims, self.cls_name)
         if self.use_batch_statistics is None:
             if self.training:
                 return self.bn_train(x,
@@ -231,29 +238,33 @@ class _BatchNorm(Cell):
 
 
 @constexpr
-def _channel_check(channel, num_channel):
+def _channel_check(channel, num_channel, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if channel != num_channel:
-        raise ValueError("the input channel is not equal with num_channel")
+        raise ValueError(f"{msg_prefix} channel should be equal with num_channel, but got channel: "
+                         f"{channel}, num_channel: {num_channel}.")
 
 
 @constexpr
-def _shape_check(in_shape):
+def _shape_check(in_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(in_shape) != 4:
-        raise ValueError("The input must has 4 dims.")
+        raise ValueError(f"{msg_prefix} in_shape must has 4 dims, but got the length of in_shape: {len(in_shape)}.")
 
 
 @constexpr
-def _shape_check_bn(in_shape, in_dims):
+def _shape_check_bn(in_shape, in_dims, prim_name=None):
     """check input dims of batch norm."""
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     dim = len(in_shape)
     if in_dims == '1d' and dim != 2:
-        raise ValueError("The input must has 2 dims.")
+        raise ValueError(f"{msg_prefix} in_shape must have 2 dims, but got {len(in_shape)}.")
     if in_dims == '2d' and dim != 4:
-        raise ValueError("The input must has 4 dims.")
+        raise ValueError(f"{msg_prefix} in_shape must have 4 dims, but got {len(in_shape)}.")
     if in_dims == '3d' and dim != 5:
-        raise ValueError("The input must has 5 dims.")
+        raise ValueError(f"{msg_prefix} in_shape must have 5 dims, but got {len(in_shape)}.")
     if in_dims == 'both' and dim != 2 and dim != 4:
-        raise ValueError("The input must has 2 dims or 4 dims.")
+        raise ValueError(f"{msg_prefix} in_shape must have 2 dims or 4 dims, but got {len(in_shape)}.")
 
 
 @constexpr
@@ -472,9 +483,11 @@ class BatchNorm2d(_BatchNorm):
 
 
 @constexpr
-def _check_3d_shape(input_shape):
+def _check_3d_shape(input_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(input_shape) != 5:
-        raise ValueError("For BatchNorm3d, input data must be 5-dimensional.")
+        raise ValueError(f"{msg_prefix} input_shape must be 5-dimensional, but got the length of input_shape: "
+                         f"{len(input_shape)}.")
 
 
 class BatchNorm3d(Cell):
@@ -570,7 +583,7 @@ class BatchNorm3d(Cell):
 
     def construct(self, input_x):
         x_shape = F.shape(input_x)
-        _check_3d_shape(x_shape)
+        _check_3d_shape(x_shape, self.cls_name)
         input_x = self.reshape(input_x, (x_shape[0], x_shape[1], x_shape[2] * x_shape[3], x_shape[4]))
         bn2d_out = self.bn2d(input_x)
         bn3d_out = self.reshape(bn2d_out, x_shape)
@@ -686,7 +699,8 @@ class GlobalBatchNorm(_BatchNorm):
                                               input_dims='both')
         self.group_device_num = validator.check_positive_int(device_num_each_group)
         if self.group_device_num <= 1:
-            raise ValueError("the number of group must be greater than 1.")
+            raise ValueError(f"For '{self.cls_name}', the 'device_num_each_group' must be greater than 1, "
+                             f"but got {self.group_device_num}.")
 
     def _check_data_dim(self, x):
         if x.dim == 0:
@@ -874,8 +888,8 @@ class LayerNorm(Cell):
         """Initialize LayerNorm."""
         super(LayerNorm, self).__init__()
         if not isinstance(normalized_shape, (tuple, list)):
-            raise TypeError("The type of 'normalized_shape' should be tuple[int] or list[int], but '{}' type is {}."
-                            .format(normalized_shape, type(normalized_shape)))
+            raise TypeError(f"For '{self.cls_name}', the type of 'normalized_shape' should be tuple[int] or list[int], "
+                            f"but got '{normalized_shape}' and the type is {type(normalized_shape)}.")
         self.normalized_shape = normalized_shape
         self.begin_norm_axis = begin_norm_axis
         self.begin_params_axis = begin_params_axis
@@ -985,10 +999,11 @@ class InstanceNorm2d(Cell):
         args_input = {"gamma_init": gamma_init, "beta_init": beta_init}
         self.check_types_valid(args_input, 'InstanceNorm2d')
         if num_features < 1:
-            raise ValueError("num_features must be at least 1")
+            raise ValueError(f"For '{self.cls_name}', the 'num_features' must be at least 1, but got {num_features}.")
 
         if momentum < 0 or momentum > 1:
-            raise ValueError("momentum should be a number in range [0, 1], but got {}".format(momentum))
+            raise ValueError(f"For '{self.cls_name}', the 'momentum' should be a number in range [0, 1], "
+                             f"but got {momentum}.")
         self.num_features = num_features
         self.eps = eps
         self.input_dims = '2d'
@@ -1007,7 +1022,7 @@ class InstanceNorm2d(Cell):
         raise NotImplementedError
 
     def construct(self, x):
-        _shape_check_bn(self.shape(x), self.input_dims)
+        _shape_check_bn(self.shape(x), self.input_dims, self.cls_name)
         return self.instance_bn(x,
                                 self.gamma,
                                 self.beta,
@@ -1022,10 +1037,11 @@ class InstanceNorm2d(Cell):
         for key, _ in args_dict.items():
             val = args_dict[key]
             if not isinstance(val, (Tensor, numbers.Number, str, Initializer)):
-                raise TypeError(f"[{name}]Supported type for arg {key} is [Tensor, numbers.Number, str, Initializer],"
-                                f"but got {type(val)}")
+                raise TypeError(f"For '{self.cls_name}', the type of args_dict['{key}'] should be in "
+                                f"[Tensor, numbers.Number, str, Initializer], but got type {type(val)}.")
             if isinstance(val, Tensor) and val.dtype != mstype.float32:
-                raise TypeError(f"[{name}]The type of arg {key} should be float32, but got {val.dtype}")
+                raise TypeError(f"For '{self.cls_name}', the type of args_dict['{key}'] should be float32, "
+                                f"but got {val.dtype}.")
 
 
 class GroupNorm(Cell):
@@ -1090,7 +1106,8 @@ class GroupNorm(Cell):
         self.num_groups = validator.check_positive_int(num_groups)
         self.num_channels = validator.check_positive_int(num_channels)
         if num_channels % num_groups != 0:
-            raise ValueError("num_channels should be divided by num_groups")
+            raise ValueError(f"For '{self.cls_name}', the 'num_channels' should be divided by 'num_groups', "
+                             f"but got 'num_channels': {num_channels}, 'num_groups': {num_groups}.")
         self.eps = validator.check_value_type('eps', eps, (float,), type(self).__name__)
         self.affine = validator.check_bool(affine)
 
@@ -1112,7 +1129,7 @@ class GroupNorm(Cell):
     def _cal_output(self, x):
         """calculate groupnorm output"""
         batch, channel, height, width = self.shape(x)
-        _channel_check(channel, self.num_channels)
+        _channel_check(channel, self.num_channels, self.cls_name)
         x = self.reshape(x, (batch, self.num_groups, -1))
         mean = self.reduce_mean(x, 2)
         var = self.reduce_sum(self.square(x - mean), 2) / (channel * height * width / self.num_groups)
@@ -1123,7 +1140,7 @@ class GroupNorm(Cell):
         return output
 
     def construct(self, x):
-        _shape_check(self.shape(x))
+        _shape_check(self.shape(x), self.cls_name)
         output = self._cal_output(x)
         return output
 

mindspore/nn/layer/pooling.py

@@ -32,12 +32,13 @@ class _PoolNd(Cell):
         self.pad_mode = validator.check_string(pad_mode.upper(), ['VALID', 'SAME'], 'pad_mode', self.cls_name)
         self.format = validator.check_string(data_format, ['NCHW', 'NHWC'], 'format', self.cls_name)
         if context.get_context("device_target") != "GPU" and self.format == "NHWC":
-            raise ValueError("NHWC format only support in GPU target.")
+            raise ValueError(f"For '{self.cls_name}, the 'NHWC' format only support in GPU target, but got device "
+                             f"target {context.get_context('device_target')}.")
 
         def _check_int_or_tuple(arg_name, arg_value):
             validator.check_value_type(arg_name, arg_value, [int, tuple], self.cls_name)
-            error_msg = f'For \'{self.cls_name}\' the {arg_name} should be an positive int number or ' \
-                        f'a tuple of two positive int numbers, but got {arg_value}'
+            error_msg = f"For '{self.cls_name}', the '{arg_name}' should be an positive int number or " \
+                        f"a tuple of two positive int numbers, but got {arg_value}"
             if isinstance(arg_value, int):
                 if arg_value <= 0:
                     raise ValueError(error_msg)
@@ -61,9 +62,10 @@ class _PoolNd(Cell):
 
 
 @constexpr
-def _shape_check(in_shape):
+def _shape_check(in_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(in_shape) != 3:
-        raise ValueError("The input must has 3 dim")
+        raise ValueError(f"{msg_prefix} input must has 3 dim, but got {len(in_shape)}")
 
 
 class MaxPool2d(_PoolNd):
@@ -216,7 +218,7 @@ class MaxPool1d(_PoolNd):
         self.squeeze = P.Squeeze(2)
 
     def construct(self, x):
-        _shape_check(self.shape(x))
+        _shape_check(self.shape(x), self.cls_name)
         x = self.expand(x, 2)
         output = self.max_pool(x)
         output = self.squeeze(output)
@@ -382,7 +384,7 @@ class AvgPool1d(_PoolNd):
         self.squeeze = P.Squeeze(2)
 
     def construct(self, x):
-        x = F.depend(x, _shape_check(self.shape(x)))
+        x = F.depend(x, _shape_check(self.shape(x), self.cls_name))
         batch, channel, width = self.shape(x)
         if width == self.kernel_size[1]:
             x = self.reduce_mean(x, 2)

mindspore/nn/layer/quant.py

@@ -408,13 +408,15 @@ class FakeQuantWithMinMaxObserver(UniformQuantObserver):
         min_array = self._get_init_array(self.min_init)
         max_array = self._get_init_array(self.max_init)
         if not np.greater(max_array, min_array).all():
-            raise ValueError("`min_init` is not less than `max_init`, please reset the initial value.")
+            raise ValueError(f"For '{self.cls_name}', the 'max_init' should be greater than 'min_init', "
+                             f"but got 'max_array': {max_array}, 'min_init': {min_init}.")
         if self.mode == "DEFAULT":
             self._default_init(min_array, max_array)
         elif self.mode == "LEARNED_SCALE":
             self._learned_scale_init(min_array, max_array)
         else:
-            raise ValueError("Invalid mode, currently only valid for `DEFAULT` and `LEARNED_SCALE` mode.")
+            raise ValueError(f"For '{self.cls_name}', only `DEFAULT` and `LEARNED_SCALE` mode are valid, but got "
+                             f"'mode': {self.mode}.")
 
     def reset(self, quant_dtype=QuantDtype.INT8, min_init=-6, max_init=6):
         r"""
@@ -433,12 +435,14 @@ class FakeQuantWithMinMaxObserver(UniformQuantObserver):
             min_array = self._get_init_array(self.min_init)
             max_array = self._get_init_array(self.max_init)
             if not np.greater(max_array, min_array).all():
-                raise ValueError("`min_init` is not less than `max_init`, please reset the initial value.")
+                raise ValueError(f"For '{self.cls_name}', the 'max_init' should be greater than 'min_init', "
+                                 f"but got 'max_array': {max_array}, 'min_init': {min_init}.")
+
             self.minq.set_data(Tensor(min_array))
             self.maxq.set_data(Tensor(max_array))
             self.quant_max.set_data(Tensor(np.array([self._quant_max]).astype(np.float32)))
         else:
-            raise ValueError("The `reset` function is currently only valid for `LEARNED_SCALE` mode.")
+            raise ValueError(f"For '{self.cls_name}', only `LEARNED_SCALE` mode is valid, but got 'mode': {self.mode}.")
 
     def _default_init(self, min_array, max_array):
         """
@@ -479,16 +483,18 @@ class FakeQuantWithMinMaxObserver(UniformQuantObserver):
         Initialization of `LEARNED_SCALE` mode.
         """
         if not self.symmetric:
-            raise ValueError("The 'LEARNED_SCALE' mode only support symmetric quant, "
-                             "please set symmetric to True.")
+            raise ValueError(f"For '{self.cls_name}', the 'LEARNED_SCALE' mode only support 'symmetric' quant, "
+                             f"but got 'symmetric': {self.symmetric}. Please set 'symmetric' to True.")
         if self.neg_trunc:
             min_array = self._get_init_array(0)
             if self.narrow_range:
-                raise ValueError("The 'LEARNED_SCALE' mode only support the combination of "
-                                 "neg_trunc=True and narrow_range=False config scenario.")
+                raise ValueError(f"For '{self.cls_name}', the 'LEARNED_SCALE' mode only support the combination of "
+                                 f"'neg_trunc=True and narrow_range=False' config scenario, but got 'narrow_range': "
+                                 f"{self.narrow_range}.")
         elif not self.narrow_range:
-            raise ValueError("The 'LEARNED_SCALE' mode only support narrow_range=True config, "
-                             "except for neg_trunc=True scenario.")
+            raise ValueError(f"For '{self.cls_name}', the 'LEARNED_SCALE' mode only support 'narrow_range=True' "
+                             f"config, except for 'neg_trunc=True' scenario. But got 'narrow_range': "
+                             f"{self.narrow_range}.")
 
         self._calculate_quant_max()
 
@@ -514,11 +520,11 @@ class FakeQuantWithMinMaxObserver(UniformQuantObserver):
         Convert the initial value to array.
         """
         if isinstance(init_date, list) and self.per_channel and len(init_date) != self.num_channels:
-            raise ValueError("The length of the min_init/max_init list should be equal to num_channels for "
-                             "perchannel quant scenario, but get {}".format(len(init_date)))
+            raise ValueError(f"For '{self.cls_name}', the length of 'min_init/max_init' list should be equal to "
+                             f"'num_channels' for perchannel quant scenario, but got {len(init_date)}.")
         if isinstance(init_date, list) and not self.per_channel and len(init_date) != 1:
-            raise ValueError("The length of the min_init/max_init list should be 1 for perlayer quant "
-                             "scenario, but get {}".format(len(init_date)))
+            raise ValueError(f"For '{self.cls_name}', the length of the 'min_init/max_init' list should be 1 for "
+                             f"perlayer quant scenario, but got {len(init_date)}.")
 
         if isinstance(init_date, list):
             min_max_array = np.array(init_date).astype(np.float32)
@@ -690,8 +696,8 @@ class Conv2dBnFoldQuantOneConv(Cell):
         for dilation_elem in self.dilation:
             Validator.check_positive_int(dilation_elem, 'dilation item', self.cls_name)
         if pad_mode not in ('valid', 'same', 'pad'):
-            raise ValueError('Attr \'pad_mode\' of \'Conv2dBnFoldQuant\' Op passed '
-                             + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')
+            raise ValueError(f"For '{self.cls_name}', the 'pad_mode' should be one of values "
+                             f"in ('valid', 'same', 'pad'), but got {pad_mode}.")
         self.pad_mode = pad_mode
         if isinstance(padding, int):
             Validator.check_non_negative_int(padding, 'padding', self.cls_name)
@@ -701,7 +707,8 @@ class Conv2dBnFoldQuantOneConv(Cell):
                 Validator.check_non_negative_int(pad, 'padding item', self.cls_name)
             self.padding = padding
         else:
-            raise TypeError("padding type must be int/tuple(int) cannot be {}!".format(type(padding)))
+            raise TypeError(f"For '{self.cls_name}', the type of 'padding' must be int/tuple(int), but got "
+                            f"{type(padding)}!")
         self.group = Validator.check_positive_int(group)
         self.eps = eps
         self.momentum = 1 - momentum
@@ -931,8 +938,8 @@ class Conv2dBnFoldQuant(Cell):
         for dilation_elem in self.dilation:
             Validator.check_positive_int(dilation_elem, 'dilation item', self.cls_name)
         if pad_mode not in ('valid', 'same', 'pad'):
-            raise ValueError('Attr \'pad_mode\' of \'Conv2dBnFoldQuant\' Op passed '
-                             + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')
+            raise ValueError(f"For '{self.cls_name}', the 'pad_mode' should be one of values in "
+                             f"('valid', 'same', 'pad'), but got {pad_mode}.")
         self.pad_mode = pad_mode
         if isinstance(padding, int):
             Validator.check_non_negative_int(padding, 'padding', self.cls_name)
@@ -942,7 +949,8 @@ class Conv2dBnFoldQuant(Cell):
                 Validator.check_non_negative_int(pad, 'padding item', self.cls_name)
             self.padding = padding
         else:
-            raise TypeError("padding type must be int/tuple(int) cannot be {}!".format(type(padding)))
+            raise TypeError(f"For '{self.cls_name}', the type of 'padding' must be int/tuple(int), "
+                            f"but got {type(padding)}!")
         self.group = Validator.check_positive_int(group)
         self.eps = eps
         self.momentum = momentum
@@ -990,7 +998,8 @@ class Conv2dBnFoldQuant(Cell):
             self.batchnorm_fold2_train = Q.BatchNormFold2(freeze_bn=freeze_bn)
             self.batchnorm_fold2_infer = Q.BatchNormFold2(freeze_bn=0)
         else:
-            raise ValueError("Unsupported platform: {}".format(context.get_context('device_target')))
+            raise ValueError(f"For '{self.cls_name}', only the 'Ascend' and 'GPU' platforms"
+                             f" are supported, but got {context.get_context('device_target')}.")
         self.step = Parameter(initializer('normal', [1], dtype=mstype.int32), name='step', requires_grad=False)
         self.one = Tensor(1, mstype.int32)
         self.assignadd = P.AssignAdd()
@@ -1141,8 +1150,8 @@ class Conv2dBnWithoutFoldQuant(Cell):
         for dilation_elem in self.dilation:
             Validator.check_positive_int(dilation_elem, 'dilation item', self.cls_name)
         if pad_mode not in ('valid', 'same', 'pad'):
-            raise ValueError('Attr \'pad_mode\' of \'Conv2dBnWithoutFoldQuant\' Op passed '
-                             + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')
+            raise ValueError(f"For '{self.cls_name}', the 'pad_mode' should be one of values in "
+                             f"('valid', 'same', 'pad'), but got {pad_mode}.")
         self.pad_mode = pad_mode
         if isinstance(padding, int):
             Validator.check_non_negative_int(padding, 'padding', self.cls_name)
@@ -1152,9 +1161,9 @@ class Conv2dBnWithoutFoldQuant(Cell):
                 Validator.check_non_negative_int(pad, 'padding item', self.cls_name)
             self.padding = padding
         else:
-            raise TypeError("padding type must be int/tuple(int) cannot be {}!".format(type(padding)))
+            raise TypeError(f"For '{self.cls_name}', the type of 'padding' must be int/tuple(int), "
+                            f"but got {type(padding)}!")
         self.group = Validator.check_positive_int(group)
-
         self.bias_add = P.BiasAdd()
         if Validator.check_bool(has_bias):
             self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')
@@ -1285,8 +1294,8 @@ class Conv2dQuant(Cell):
         for dilation_elem in self.dilation:
             Validator.check_positive_int(dilation_elem, 'dilation item', self.cls_name)
         if pad_mode not in ('valid', 'same', 'pad'):
-            raise ValueError('Attr \'pad_mode\' of \'Conv2dQuant\' Op passed '
-                             + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')
+            raise ValueError(f"For '{self.cls_name}', the 'pad_mode' should be one of values "
+                             f"in ('valid', 'same', 'pad'), but got {pad_mode}.")
         self.pad_mode = pad_mode
         if isinstance(padding, int):
             Validator.check_non_negative_int(padding, 'padding', self.cls_name)
@@ -1296,7 +1305,8 @@ class Conv2dQuant(Cell):
                 Validator.check_non_negative_int(pad, 'padding item', self.cls_name)
             self.padding = padding
         else:
-            raise TypeError("padding type must be int/tuple(int) cannot be {}!".format(type(padding)))
+            raise TypeError(f"For '{self.cls_name}', the type of 'padding' must be int/tuple(int), "
+                            f"but got {type(padding)}!")
         self.group = Validator.check_positive_int(group)
 
         weight_shape = [out_channels, in_channels // group, *self.kernel_size]
@@ -1414,7 +1424,10 @@ class DenseQuant(Cell):
         if isinstance(weight_init, Tensor):
             if weight_init.ndim != 2 or weight_init.shape[0] != out_channels or \
                     weight_init.shape[1] != in_channels:
-                raise ValueError("weight_init shape error")
+                raise ValueError(f"For '{self.cls_name}', weight init shape error. The ndim of 'weight_init' should "
+                                 f"be equal to 2, and the first dim should be equal to 'out_channels', and the "
+                                 f"second dim should be equal to 'in_channels'. But got 'weight_init': {weight_init}, "
+                                 f"'out_channels': {out_channels}, 'in_channels': {in_channels}.")
 
         self.weight = Parameter(initializer(
             weight_init, [out_channels, in_channels]), name="weight")
@@ -1422,7 +1435,9 @@ class DenseQuant(Cell):
         if self.has_bias:
             if isinstance(bias_init, Tensor):
                 if bias_init.ndim != 1 or bias_init.shape[0] != out_channels:
-                    raise ValueError("bias_init shape error")
+                    raise ValueError(f"For '{self.cls_name}', bias init shape error. The ndim of 'bias_init' should "
+                                     f"be equal to 1, and the first dim should be equal to 'out_channels'. But got "
+                                     f"'bias_init': {bias_init}, 'out_channels': {out_channels}.")
 
             self.bias = Parameter(initializer(
                 bias_init, [out_channels]), name="bias")
@@ -1432,7 +1447,9 @@ class DenseQuant(Cell):
 
         self.activation = get_activation(activation) if isinstance(activation, str) else activation
         if activation is not None and not isinstance(self.activation, (Cell, Primitive)):
-            raise TypeError("The activation must be str or Cell or Primitive,"" but got {}.".format(activation))
+            raise TypeError(f"For '{self.cls_name}', the 'activation' must be str or Cell or Primitive, "
+                            f"but got {activation}.")
+
         self.activation_flag = self.activation is not None
         self.fake_quant_weight = quant_config.weight(ema=False,
                                                      channel_axis=0,

mindspore/nn/layer/rnns.py

@@ -110,7 +110,8 @@ class _DynamicRNN(Cell):
         elif mode == "GRU":
             cell = _gru_cell
         else:
-            raise ValueError("Unrecognized RNN mode: " + mode)
+            raise ValueError(f"For '{self.cls_name}', the 'mode' should be in ['RNN_RELU', 'RNN_TANH', 'LSTM', 'GRU'], "
+                             f"but got {mode}.")
         self.cell = cell
         self.is_lstm = mode == "LSTM"
 
@@ -187,10 +188,8 @@ class _RNNBase(Cell):
         validator.check_value_type("bidirectional", bidirectional, [bool], self.cls_name)
 
         if not 0 <= dropout < 1:
-            raise ValueError(f"For '{self.cls_name}', "
-                             "dropout should be a number in range [0, 1) "
-                             "representing the probability of an element being "
-                             "zeroed")
+            raise ValueError(f"For '{self.cls_name}', the 'dropout' should be a number in range [0, 1) "
+                             f"representing the probability of an element being zeroed, but got {dropout}.")
 
         if dropout > 0 and num_layers == 1:
             logger.warning("dropout option adds dropout after all but last "
@@ -206,7 +205,8 @@ class _RNNBase(Cell):
         elif mode == "RNN_RELU":
             gate_size = hidden_size
         else:
-            raise ValueError("Unrecognized RNN mode: " + mode)
+            raise ValueError(f"For '{self.cls_name}', the 'mode' should be in ['RNN_RELU', 'RNN_TANH', 'LSTM', 'GRU'], "
+                             f"but got {mode}.")
 
         self.reverse = P.ReverseV2([0])
         self.reverse_sequence = P.ReverseSequence(0, 1)
@@ -424,8 +424,8 @@ class RNN(_RNNBase):
             elif kwargs['nonlinearity'] == 'relu':
                 mode = 'RNN_RELU'
             else:
-                raise ValueError("Unknown nonlinearity '{}'".format(
-                    kwargs['nonlinearity']))
+                raise ValueError(f"For '{self.cls_name}', the 'nonlinearity' should be in ['tanh', 'relu'], "
+                                 f"but got {kwargs['nonlinearity']}.")
             del kwargs['nonlinearity']
         else:
             mode = 'RNN_TANH'
@@ -583,7 +583,8 @@ class RNNCell(_RNNCellBase):
     def __init__(self, input_size: int, hidden_size: int, has_bias: bool = True, nonlinearity: str = "tanh"):
         super().__init__(input_size, hidden_size, has_bias, num_chunks=1)
         if nonlinearity not in self._non_linearity:
-            raise ValueError("Unknown nonlinearity: {}".format(nonlinearity))
+            raise ValueError(f"For '{self.cls_name}', the 'nonlinearity' should be in ['tanh', 'relu'], "
+                             f"but got {nonlinearity}.")
         self.nonlinearity = nonlinearity
 
     def construct(self, inputs, hx):

mindspore/nn/layer/thor_layer.py

@@ -98,13 +98,18 @@ class DenseThor(Cell):
         if isinstance(weight_init, Tensor):
             if weight_init.dim() != 2 or weight_init.shape[0] != out_channels or \
                     weight_init.shape[1] != in_channels:
-                raise ValueError("Weight init shape error.")
+                raise ValueError(f"For '{self.cls_name}', weight init shape error. The dim of 'weight_init' should "
+                                 f"be equal to 2, and the first dim should be equal to 'out_channels', and the "
+                                 f"second dim should be equal to 'in_channels'. But got 'weight_init': {weight_init}, "
+                                 f"'out_channels': {out_channels}, 'in_channels': {in_channels}.")
         self.weight = Parameter(initializer(weight_init, [out_channels, in_channels]), name="weight")
         self.bias = None
         if self.has_bias:
             if isinstance(bias_init, Tensor):
                 if bias_init.dim() != 1 or bias_init.shape[0] != out_channels:
-                    raise ValueError("Bias init shape error.")
+                    raise ValueError(f"For '{self.cls_name}', bias init shape error. The dim of 'bias_init' should "
+                                     f"be equal to 1, and the first dim should be equal to 'out_channels'. But got "
+                                     f"'bias_init': {bias_init}, 'out_channels': {out_channels}.")
             self.bias = Parameter(initializer(bias_init, [out_channels]), name="bias")
             self.bias_add = P.BiasAdd()
 
@@ -211,7 +216,8 @@ class _ConvThor(Cell):
             Validator.check_non_negative_int(padding, 'padding', self.cls_name)
             self.padding = padding
         else:
-            raise TypeError("padding type must be int or tuple(int) cannot be {}!".format(type(padding)))
+            raise TypeError(f"For '{self.cls_name}', the type of 'padding' must be int/tuple(int), but got "
+                            f"{type(padding)}.")
 
         self.dilation = dilation
         self.group = Validator.check_positive_int(group)
@@ -220,11 +226,11 @@ class _ConvThor(Cell):
         self.__validate_stride(stride)
         self.__validate_dilation(dilation)
         if in_channels % group != 0:
-            raise ValueError("Attr 'in_channels' of 'Conv2DThor' Op must be divisible by "
-                             "attr 'group' of 'Conv2DThor' Op.")
+            raise ValueError(f"For '{self.cls_name}', the 'in_channels' must be divisible by 'group', but got "
+                             f"'in_channels': {in_channels} and 'group': {group}.")
         if out_channels % group != 0:
-            raise ValueError("Attr 'out_channels' of 'Conv2DThor' Op must be divisible by "
-                             "attr 'group' of 'Conv2DThor' Op.")
+            raise ValueError(f"For '{self.cls_name}', the 'out_channels' must be divisible by 'group', but got "
+                             f"'out_channels': {out_channels} and 'group': {group}.")
         if not transposed:
             shape = [out_channels, in_channels // group, *kernel_size]
         else:
@@ -243,22 +249,22 @@ class _ConvThor(Cell):
         if (not isinstance(kernel_size[0], int)) or (not isinstance(kernel_size[1], int)) or \
                 isinstance(kernel_size[0], bool) or isinstance(kernel_size[1], bool) or \
                 kernel_size[0] < 1 or kernel_size[1] < 1:
-            raise ValueError("Attr 'kernel_size' of 'Conv2D' Op passed "
-                             + str(self.kernel_size) + ", should be a int or tuple and equal to or greater than 1.")
+            raise ValueError(f"For '{self.cls_name}', all elements in 'kernel_size' should be int or tuple and "
+                             f"equal to or greater than 1, but got 'kernel_size': {kernel_size}.")
 
     def __validate_stride(self, stride):
         """validate stride."""
         if (not isinstance(stride[0], int)) or (not isinstance(stride[1], int)) or \
                 isinstance(stride[0], bool) or isinstance(stride[1], bool) or stride[0] < 1 or stride[1] < 1:
-            raise ValueError("Attr 'stride' of 'Conv2D' Op passed "
-                             + str(self.stride) + ", should be a int or tuple and equal to or greater than 1.")
+            raise ValueError(f"For '{self.cls_name}', all elements in 'stride' should be int or tuple and "
+                             f"equal to or greater than 1, but got 'stride': {stride}.")
 
     def __validate_dilation(self, dilation):
         """validate dilation."""
         if (not isinstance(dilation[0], int)) or (not isinstance(dilation[1], int)) or \
                 isinstance(dilation[0], bool) or isinstance(dilation[1], bool) or dilation[0] < 1 or dilation[1] < 1:
-            raise ValueError("Attr 'dilation' of 'Conv2D' Op passed "
-                             + str(self.dilation) + ", should be a int or tuple and equal to or greater than 1.")
+            raise ValueError(f"For '{self.cls_name}', all elements in 'dilation' should be int or tuple and "
+                             f"equal to or greater than 1, but got 'dilation': {dilation}.")
 
 
 class Conv2dThor(_ConvThor):
@@ -420,8 +426,8 @@ class Conv2dThor(_ConvThor):
         """Initialize depthwise conv2d op"""
         if context.get_context("device_target") == "Ascend" and self.group > 1:
             self.dilation = self._dilation
-            Validator.check_integer('group', self.group, self.in_channels, Rel.EQ)
-            Validator.check_integer('group', self.group, self.out_channels, Rel.EQ)
+            Validator.check_int('group', self.group, self.in_channels, Rel.EQ)
+            Validator.check_int('group', self.group, self.out_channels, Rel.EQ)
             self.conv2d = P.DepthwiseConv2dNative(channel_multiplier=1,
                                                   kernel_size=self.kernel_size,
                                                   pad_mode=self.pad_mode,
@@ -724,10 +730,11 @@ class EmbeddingLookupThor(Cell):
         self.forward_unique = False
         self.dtype = mstype.float16
         if target not in ('CPU', 'DEVICE'):
-            raise ValueError('Attr \'target\' of \'EmbeddingLookup\' Op passed '
-                             + str(target) + ', should be one of values in \'CPU\', \'DEVICE\'.')
+            raise ValueError(f"For '{self.cls_name}', the 'target' should be one of values in ('CPU', 'DEVICE'), "
+                             f"but got {target}.")
         if not sparse and target == 'CPU':
-            raise ValueError('When target is CPU, embedding_lookup must be sparse.')
+            raise ValueError(f"For '{self.cls_name}', embedding_lookup must be sparse when 'target' is CPU, but got "
+                             f"'sparse': {sparse}, 'target': {target}.")
         if sparse:
             self.gatherv2 = P.SparseGatherV2()
         else:
@@ -755,9 +762,11 @@ class EmbeddingLookupThor(Cell):
         indices_shape_size = 2
         if slice_mode == "field_slice" and is_auto_parallel:
             if not manual_shapes:
-                raise ValueError("in slice field mode, the manual_shapes should not be none")
+                raise ValueError(f"For '{self.cls_name}', the 'manual_shapes' should not be none "
+                                 f"when 'slice_mode' is 'field_slice'.")
             if not isinstance(manual_shapes, tuple):
-                raise TypeError("manual_shapes type must be tuple(int) cannot be {}!".format(type(manual_shapes)))
+                raise TypeError(f"For '{self.cls_name}', the type of 'manual_shapes' must be tuple(int), but got "
+                                f"type {type(manual_shapes)}.")
             for dim in manual_shapes:
                 Validator.check_positive_int(dim, 'manual shape dim', self.cls_name)
             self.gatherv2.add_prim_attr("manual_split", manual_shapes)
@@ -789,11 +798,13 @@ class EmbeddingLookupThor(Cell):
             self.embeddinglookup.shard(((1, 1), indices_strategy))
         else:
             if is_auto_parallel:
-                raise ValueError("slice_mode should support mode in nn.EmbeddingLookup, but get "
-                                 + str(slice_mode))
+                raise ValueError(f"For '{self.cls_name}', the 'slice_mode' should be one of values in "
+                                 f"['field_slice', 'table_row_slice', 'table_column_slice', 'batch_slice'], "
+                                 f"but got 'slice_mode': {slice_mode}")
         if self.cache_enable and not enable_ps:
             if parallel_mode != ParallelMode.STAND_ALONE:
-                raise ValueError("parallel mode haven't supported cache enable yet.")
+                raise ValueError(f"For '{self.cls_name}', the 'parallel_mode' should be equal to "
+                                 f"'ParallelMode.STAND_ALONE', but got {parallel_mode}.")
             self._set_cache_enable()
         self.embedding_table.unique = self.forward_unique
         self.max_norm = max_norm
@@ -834,11 +845,14 @@ class EmbeddingLookupThor(Cell):
     def _set_cache_enable(self):
         """EmbeddingLookup cache check for not ps env, which is only support 'ascend'."""
         if self.target != 'DEVICE':
-            raise ValueError("The configuration of 'vocab_cache_size' is valid only in 'DEVICE' target.")
+            raise ValueError(f"For '{self.cls_name}', the configuration of 'vocab_cache_size' is valid "
+                             f"only when 'target' is 'DEVICE', but got 'target': {self.target}.")
         if not self.sparse:
-            raise ValueError("The configuration of 'vocab_cache_size' is valid only 'sparse' is true.")
+            raise ValueError(f"For '{self.cls_name}', the configuration of 'vocab_cache_size' is valid "
+                             f"only when 'sparse' is true, but got 'sparse': {self.sparse}.")
         if context.get_context("device_target") != 'Ascend':
-            raise ValueError("The configuration of 'vocab_cache_size' is valid only in 'ascend'.")
+            raise ValueError(f"For '{self.cls_name}', the configuration of 'vocab_cache_size' is valid "
+                             f"only when 'device_target' is 'Ascend', but got {context.get_context('device_target')}.")
 
         logger.info("EmbeddingLookup cache enable takes effect.")
         self.forward_unique = True
@@ -869,17 +883,18 @@ class EmbeddingLookupThor(Cell):
                 rank_id = get_rank()
                 full_batch = _get_full_batch()
                 if rank_size > 1 and not (full_batch and slice_mode == "table_row_slice"):
-                    raise ValueError("The embeddingLookup cache of parameter server parallel only be used "
-                                     "in 'full_batch' and 'table_row_slice' parallel strategy.")
+                    raise ValueError(f"For '{self.cls_name}', the embeddingLookup cache of parameter server parallel "
+                                     f"only be used in 'full_batch' and 'table_row_slice' parallel strategy, but got "
+                                     f"'full_batch': {full_batch}, 'slice_mode': {slice_mode}.")
                 self.vocab_cache_size = self.vocab_cache_size * rank_size
                 _set_rank_id(rank_id)
             self.cache_enable = True
             if _is_role_worker():
                 self.vocab_size = self.vocab_cache_size
                 if context.get_context("enable_sparse") != self.sparse:
-                    raise ValueError("The value of parameter 'sparse' must be same for all EmbeddingLookup "
-                                     "kernels and equal the value of 'enable_sparse' in context setting in "
-                                     "parameter server cache mode")
+                    raise ValueError(f"For '{self.cls_name}', the 'sparse' must be equal to the 'enable_sparse' "
+                                     f"in context setting in parameter server cache mode, but got 'sparse': "
+                                     f"{self.sparse}, 'enable_sparse': {context.get_context('enable_sparse')}.")
 
     def _set_voacb_cache_enable_for_ps(self, vocab_cache_size, embedding_size, vocab_size):
         """PS embeddingLookup cache enable set."""

mindspore/nn/layer/timedistributed.py

@@ -24,17 +24,22 @@ __all__ = ['TimeDistributed']
 
 
 @constexpr
-def _check_reshape_pos(reshape_pos, inputs_shape, outputs_shape):
+def _check_reshape_pos(reshape_pos, inputs_shape, outputs_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if reshape_pos >= len(outputs_shape) or inputs_shape[reshape_pos] != outputs_shape[reshape_pos]:
-        raise ValueError("The parameter reshape_with_axis is invalid in the input and output of TimeDistributed. "
-                         "You may try pass parameters without reshape_with_axis.")
+        raise ValueError(f"{msg_prefix} 'reshape_with_axis' is invalid in the input and output. "
+                         f"The 'reshape_pos' should be less than the length of 'outputs_shape', and the "
+                         f"'inputs_shape[reshape_pos]' should be equal to 'outputs_shape[reshape_pos]', but got "
+                         f"'reshape_pos': {reshape_pos}, 'inputs_shape': {inputs_shape}, 'outputs_shape': "
+                         f"{outputs_shape}. You may try pass parameters without 'reshape_with_axis'.")
 
 
 @constexpr
-def _check_expand_dims_axis(time_axis, ndim):
+def _check_expand_dims_axis(time_axis, ndim, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if time_axis > ndim:
-        raise ValueError("The parameter time_axis is invalid in the input. "
-                         "The value of time_axis should be in range of [{}, {}].".format(-ndim - 1, ndim))
+        raise ValueError(f"{msg_prefix} value of 'time_axis' should be in range of [{-ndim - 1}, {ndim}], "
+                         f"but got {time_axis}.")
 
 
 @constexpr
@@ -45,15 +50,17 @@ def _generate_perm(axis_a, axis_b, length):
 
 
 @constexpr
-def _check_data(flag):
+def _check_data(flag, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if not flag:
-        raise TypeError("The inputs and outputs should be a Tensor.")
+        raise TypeError(f"{msg_prefix} inputs and outputs should be a Tensor.")
 
 
 @constexpr
-def _check_inputs_dim(shape):
+def _check_inputs_dim(shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(shape) < 3:
-        raise ValueError("The inputs should be at least 3D.")
+        raise ValueError(f"{msg_prefix} inputs shape should be at least 3D, but got {len(shape)}.")
 
 
 class TimeDistributed(Cell):
@@ -97,8 +104,8 @@ class TimeDistributed(Cell):
     def __init__(self, layer, time_axis, reshape_with_axis=None):
         """Initialize TimeDistributed."""
         if not isinstance(layer, (Cell, Primitive)):
-            raise TypeError("Please initialize TimeDistributed with mindspore.nn.Cell or "
-                            "mindspore.ops.Primitive instance. You passed: {input}".format(input=layer))
+            raise TypeError(f"For '{self.cls_name}', the type of 'layer' should be mindspore.nn.Cell or "
+                            "mindspore.ops.Primitive instance, but got type: {type(layer)}.")
         super(TimeDistributed, self).__init__()
         Validator.check_is_int(time_axis)
         if reshape_with_axis is not None:
@@ -111,7 +118,7 @@ class TimeDistributed(Cell):
 
     def construct(self, inputs):
         _check_data(isinstance(inputs, Tensor))
-        _check_inputs_dim(inputs.shape)
+        _check_inputs_dim(inputs.shape, self.cls_name)
         time_axis = self.time_axis % len(inputs.shape)
         if self.reshape_with_axis is not None:
             reshape_with_axis = self.reshape_with_axis % len(inputs.shape)
@@ -126,7 +133,7 @@ class TimeDistributed(Cell):
             inputs = self.reshape(inputs, inputs_shape_new[: reshape_pos] + (-1,) + inputs_shape_new[reshape_pos + 2:])
             outputs = self.layer(inputs)
             _check_data(isinstance(outputs, Tensor))
-            _check_reshape_pos(reshape_pos, inputs.shape, outputs.shape)
+            _check_reshape_pos(reshape_pos, inputs.shape, outputs.shape, self.cls_name)
             outputs_shape_new = outputs.shape[:reshape_pos] + inputs_shape_new[reshape_pos: reshape_pos + 2]
             if reshape_pos + 1 < len(outputs.shape):
                 outputs_shape_new += outputs.shape[reshape_pos + 1:]
@@ -138,7 +145,7 @@ class TimeDistributed(Cell):
         for item in inputs:
             outputs = self.layer(item)
             _check_data(isinstance(outputs, Tensor))
-            _check_expand_dims_axis(time_axis, outputs.ndim)
+            _check_expand_dims_axis(time_axis, outputs.ndim, self.cls_name)
             y += (outputs,)
         y = Stack(time_axis)(y)
         return y

mindspore/ops/composite/array_ops.py

@@ -116,18 +116,17 @@ tensor_operator_registry.register('repeat_elements', repeat_elements)
 
 
 @constexpr
-def _check_sequence_mask_input_len(input_shape):
+def _check_sequence_mask_input_len(input_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if not input_shape:
-        raise ValueError(f"Sequence_mask lengths_shape should be > 0. "
-                         f"Current lengths_shape is {input_shape}.")
+        raise ValueError(f"{msg_prefix} lengths_shape should be greater than 0, but got {input_shape}.")
     # broadcast only supports 7d shape
     shape_size = len(input_shape)
     if shape_size >= 7:
-        raise ValueError(f"Sequence_mask lengths_shape's size only support a value less than 7. "
-                         f"Current lengths_shape is {shape_size}d.")
+        raise ValueError(f"{msg_prefix} size of lengths_shape should be less than 7, but got {shape_size}d.")
 
 
-def sequence_mask(lengths, maxlen=None):
+def sequence_mask(lengths, maxlen=None, prim_name='sequence_mask'):
     """
     Returns a mask tensor representing the first N positions of each cell.
 
@@ -188,7 +187,7 @@ def sequence_mask(lengths, maxlen=None):
     to_tensor_op = P.ScalarToArray()
 
     const_utils.check_type_valid(F.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
-    _check_sequence_mask_input_len(shape_op(lengths))
+    _check_sequence_mask_input_len(shape_op(lengths), prim_name)
 
     if maxlen is None:
         flatten_data = reshape_op(lengths, (-1,))

mindspore/ops/composite/base.py

@@ -319,11 +319,11 @@ class GradOperation(GradOperation_):
     def __init__(self, get_all=False, get_by_list=False, sens_param=False):
         """Initialize GradOperation."""
         if not isinstance(get_all, bool):
-            raise TypeError(f'get_all should be bool, but got {type(get_all)}')
+            raise TypeError(f"For 'GradOperation', the 'get_all' should be bool, but got {type(get_all)}")
         if not isinstance(get_by_list, bool):
-            raise TypeError(f'get_by_list should be bool, but got {type(get_by_list)}')
+            raise TypeError(f"For 'GradOperation', the 'get_by_list' should be bool, but got {type(get_by_list)}")
         if not isinstance(sens_param, bool):
-            raise TypeError(f'sens_param should be bool, but got {type(sens_param)}')
+            raise TypeError(f"For 'GradOperation', the 'sens_param' should be bool, but got {type(sens_param)}")
         self.get_all = get_all
         self.get_by_list = get_by_list
         self.sens_param = sens_param
@@ -443,7 +443,7 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
                 continue
             output = fn(*args)
             return output
-        raise ValueError("Cannot find fn match given args.")
+        raise ValueError(f"For 'MultitypeFuncGraph', cannot find fn match given args.")
 
     def register(self, *type_names):
         """
@@ -461,7 +461,8 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
                 if isinstance(type_input, str):
                     return mstype.typing.str_to_type(type_input)
                 if not isinstance(type_input, mstype.Type):
-                    raise TypeError(f"MultitypeFuncGraph register only support str or {mstype.Type}")
+                    raise TypeError(f"For 'MultitypeFuncGraph', register only support str or {mstype.Type}, but got "
+                                    f"'type_input': {type_input}.")
                 return type_input
 
             types = tuple(map(convert_type, type_names))

mindspore/ops/composite/clip_ops.py

@@ -26,9 +26,11 @@ from mindspore.ops.primitive import constexpr
 
 
 @constexpr
-def _check_shape(input_shape, out_shape):
+def _check_shape(input_shape, out_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if input_shape != out_shape:
-        raise ValueError("Cannot broadcast the shape of x to the shape of clip_value_min or clip_value_max.")
+        raise ValueError(f"{msg_prefix} input_shape should be equal to the out_shape, but got "
+                         f"input_shape {input_shape} and out_shape {out_shape}.")
 
 
 def clip_by_value(x, clip_value_min, clip_value_max):
@@ -74,7 +76,7 @@ def clip_by_value(x, clip_value_min, clip_value_max):
     max_op = P.Maximum()
     x_min = min_op(x, clip_value_max)
     x_max = max_op(x_min, clip_value_min)
-    _check_shape(F.shape(x), F.shape(x_max))
+    _check_shape(F.shape(x), F.shape(x_max), 'clip_by_value')
     return x_max
 
 
@@ -115,7 +117,8 @@ class _ClipByGlobalNorm(Cell):
         super(_ClipByGlobalNorm, self).__init__()
         # Add interface. This parameter is not used at present
         if use_norm is not None:
-            raise ValueError("Input 'use_norm' only supports None currently!")
+            raise ValueError(f"For '{self.cls_name}', input 'use_norm' only supports None currently, "
+                             f"but got 'use_norm': {use_norm}")
         validator.check_number("clip_norm", clip_norm, 0.0, Rel.GT, self.cls_name)
         self.clip_norm = Tensor([clip_norm], mstype.float32)
         self.hyper_map = C.HyperMap()

mindspore/ops/composite/math_ops.py

@@ -119,48 +119,53 @@ def _int_to_tuple_conv(axes):
 
 
 @constexpr
-def _check_axes(axes):
+def _check_axes(axes, prim_name=None):
     """
     Check for validity and type of axes passed to function.
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     validator.check_value_type('axes', axes, [int, tuple, list], "tensor dot")
     if not isinstance(axes, int):
         axes = list(axes)  # to avoid immutability issues
         if len(axes) != 2:
-            raise ValueError("Require two axes inputs, given less")
+            raise ValueError(f"{msg_prefix} dimension of axes should be 2, but got {axes}.")
         axes = _int_to_tuple_conv(axes)  # convert before length checks
         if len(axes[0]) != len(axes[1]):
-            raise ValueError("Axes have to be the same size/length")
+            raise ValueError(f"{msg_prefix} first and second dim of axes have to be the same size/length, "
+                             f"but got {axes}.")
         if len(axes[0]) != len(set(axes[0])) or len(axes[1]) != len(set(axes[1])):
-            raise ValueError("Axes cannot have duplicating values")
+            raise ValueError(f"{msg_prefix} axes cannot have duplicating values, but got {axes}.")
     return axes
 
 
 @constexpr
-def _typecheck_input(x1_type, x2_type):
+def _typecheck_input(x1_type, x2_type, prim_name=None):
     """
     Check input tensor types to be valid and confirm they are the same type.
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     const_utils.check_type_valid(x1_type, [mstype.float32, mstype.float16], 'x1')
     const_utils.check_type_valid(x2_type, [mstype.float32, mstype.float16], 'x2')
     if x1_type != x2_type:
-        raise TypeError(f'Both Inputs must be the same Type. x1 is \'{x1_type}\' and x2 is \'{x2_type}\' ')
+        raise TypeError(f"{msg_prefix} inputs must be the same type, but got x1_type: {x1_type} "
+                        f"and x2_type: {x2_type}.")
 
 
 @constexpr
-def _axes_int_check(x1_shape, x2_shape, axes):
+def _axes_int_check(x1_shape, x2_shape, axes, prim_name=None):
     """
     Convert from single int axes to 2d tuple if required
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if isinstance(axes, int):
         if axes < 0:
-            raise ValueError(f"axes must be at least 0 for tensor dot, got {axes}")
+            raise ValueError(f"{msg_prefix} axes must be at least 0, but got {axes}.")
         if axes == 0:
             # outer product, no input validation required
             return [], []
         if axes > len(x1_shape) or axes > len(x2_shape):
-            raise ValueError(
-                "Axes value too high for given input arrays dimensions.")
+            raise ValueError(f"{msg_prefix} axes cannot be greater than the length of x1_shape and x2_shape, "
+                             f"but got axes: {axes}, x1_shape: {x1_shape}, x2_shape: {x2_shape}.")
         x1_ind = tuple(range(len(x1_shape))[-1 * axes:])
         x2_ind = tuple(range(len(x2_shape))[:axes])
         axes = tuple((x1_ind, x2_ind))
@@ -169,12 +174,13 @@ def _axes_int_check(x1_shape, x2_shape, axes):
 
 
 @constexpr
-def _validate_axes(x1_shape, x2_shape, axes):
+def _validate_axes(x1_shape, x2_shape, axes, prim_name=None):
     """
     Checks for axes having the correct length according to input, for any value in axis
     being out of range with given shape and also checking for compatible axes values
     with given inputs.
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     shapes = [x1_shape, x2_shape]
 
     # axis length check
@@ -182,8 +188,8 @@ def _validate_axes(x1_shape, x2_shape, axes):
         axes_len = len(x_axes)
         shape_dim_len = len(shapes[ix_input])
         if axes_len > shape_dim_len:
-            raise ValueError(f"axes for input: {ix_input + 1} are of length: {axes_len} "
-                             f"can only be max: {shape_dim_len} due to input shape.")
+            raise ValueError(f"{msg_prefix} length of x_axes should be less than or equal to {shape_dim_len}, "
+                             f"but got 'len(x_axes)': {axes_len}.")
 
     # axis values range check
     for ix_input, x_axes in enumerate(axes):
@@ -192,8 +198,8 @@ def _validate_axes(x1_shape, x2_shape, axes):
         min_val = -1 * len(comp_shape)
         for _, x_value in enumerate(x_axes):
             if not min_val <= x_value <= max_val:
-                raise ValueError(f"axes for input: {ix_input + 1} contains index: "
-                                 f"{x_value}, but range is: [{min_val}, {max_val}]")
+                raise ValueError(f"{msg_prefix} value in axes should be in range: [{min_val}, {max_val}], "
+                                 f"but got {x_value}.")
 
     # check axis value with input shape - both ways for axis valid
     invalid_a = False
@@ -204,7 +210,9 @@ def _validate_axes(x1_shape, x2_shape, axes):
         if x1_shape[axes[0][i]] != x2_shape[axes[1][len(axes[0])-1-i]]:
             invalid_b = True
     if invalid_a and invalid_b:
-        raise ValueError("Given Axes are incompatible with given input arrays")
+        raise ValueError(f"{msg_prefix} 'i' should exist such that 'x1_shape[axes[0][i]]' is equal to "
+                         f"'x2_shape[axes[1][i]]' or 'x2_shape[axes[1][len(axes[0])-1-i]]', but got "
+                         f"x1_shape: {x1_shape}, x2_shape: {x2_shape}, axes: {axes}.")
 
 
 @constexpr
@@ -224,7 +232,7 @@ def _calc_new_shape(shape, axes, position=0):
     return new_shape, transpose_perm, free_dims
 
 
-def tensor_dot(x1, x2, axes):
+def tensor_dot(x1, x2, axes, prim_name='tensor_dot'):
     """
     Computation of Tensor contraction on arbitrary axes between tensors `a` and `b`.
 
@@ -276,11 +284,11 @@ def tensor_dot(x1, x2, axes):
     x2_shape = shape_op(x2)
     x1_type = F.dtype(x1)
     x2_type = F.dtype(x2)
-    axes = _check_axes(axes)
-    _typecheck_input(x1_type, x2_type)
+    axes = _check_axes(axes, prim_name)
+    _typecheck_input(x1_type, x2_type, prim_name)
     # input compatibility check & axes format update
-    axes = _axes_int_check(x1_shape, x2_shape, axes)
-    _validate_axes(x1_shape, x2_shape, axes)
+    axes = _axes_int_check(x1_shape, x2_shape, axes, prim_name)
+    _validate_axes(x1_shape, x2_shape, axes, prim_name)
     x1_reshape_fwd, x1_transpose_fwd, x1_ret = _calc_new_shape(x1_shape, axes, 0)
     x2_reshape_fwd, x2_transpose_fwd, x2_ret = _calc_new_shape(x2_shape, axes, 1)
     output_shape = x1_ret + x2_ret  # combine free axes from both inputs
@@ -295,21 +303,24 @@ def tensor_dot(x1, x2, axes):
 
 
 @constexpr
-def _check_invalid_input(x1_shape, x2_shape):
+def _check_invalid_input(x1_shape, x2_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(x1_shape) < 2 or len(x2_shape) < 2:
-        raise ValueError('C.dot inputs x1, x2 should has dimension >= 2,'
-                         + f'while x1 is ({len(x1_shape)}) and x2 is ({len(x2_shape)}).')
+        raise ValueError(f"{msg_prefix} inputs x1, x2 should have 'dimension >= 2',"
+                         f"but got 'len(x1_shape)': ({len(x1_shape)}) and 'len(x2_shape)': ({len(x2_shape)}).")
 
 
 @constexpr
-def _typecheck_input_dot(x1_type, x2_type):
+def _typecheck_input_dot(x1_type, x2_type, prim_name=None):
     """
     Check input tensor types to be valid and confirm they are the same type for dot and batch dot ops.
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     const_utils.check_type_valid(x1_type, [mstype.float16, mstype.float32], 'x1')
     const_utils.check_type_valid(x2_type, [mstype.float16, mstype.float32], 'x2')
     if x1_type != x2_type:
-        raise TypeError(f'Both Inputs must be the same Type. x1 is \'{x1_type}\' and x2 is \'{x2_type}\' ')
+        raise TypeError(f"{msg_prefix} inputs must be the same type, but got "
+                        f"x1_type: {x1_type} and x2_type: {x2_type}.")
 
 
 @constexpr
@@ -319,7 +330,7 @@ def _get_transpose_shape(x2_shape):
     return x2_shape_transpose
 
 
-def dot(x1, x2):
+def dot(x1, x2, prim_name=None):
     """
     Computation a dot product between samples in two tensors.
 
@@ -394,8 +405,8 @@ def dot(x1, x2):
     x2_shape = shape_op(x2)
     x1_type = F.dtype(x1)
     x2_type = F.dtype(x2)
-    _typecheck_input_dot(x1_type, x2_type)
-    _check_invalid_input(x1_shape, x2_shape)
+    _typecheck_input_dot(x1_type, x2_type, prim_name)
+    _check_invalid_input(x1_shape, x2_shape, prim_name)
 
     if len(x1_shape) > 2 or len(x2_shape) > 2:
         x2_shape_transpose = _get_transpose_shape(x2_shape)
@@ -408,31 +419,36 @@ def dot(x1, x2):
 
 
 @constexpr
-def _get_batch_size(x1_shape, x2_shape):
+def _get_batch_size(x1_shape, x2_shape, prim_name=None):
     """
     Get batch sizes from two inputs
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if len(x1_shape) < 2 or len(x2_shape) < 2:
-        raise ValueError("Require both inputs with rank >= 2.")
+        raise ValueError(f"{msg_prefix} inputs x1, x2 should have 'dimension >= 2', "
+                         f"but got 'len(x1_shape)': ({len(x1_shape)}) and 'len(x2_shape)': ({len(x2_shape)}).")
     return x1_shape[0], x2_shape[0]
 
 
 @constexpr
-def _typecheck_input_batch_dot(x1_type, x2_type):
+def _typecheck_input_batch_dot(x1_type, x2_type, prim_name=None):
     """
     Check input tensor types to be valid and confirm they are the same type for batch dot ops.
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     const_utils.check_type_valid(x1_type, [mstype.float32], 'x1')
     const_utils.check_type_valid(x2_type, [mstype.float32], 'x2')
     if x1_type != x2_type:
-        raise TypeError(f'Both Inputs must be the same Type. x1 is \'{x1_type}\' and x2 is \'{x2_type}\' ')
+        raise TypeError(f"{msg_prefix} inputs must be the same type, but got x1_type: {x1_type} and "
+                        f"x2_type: {x2_type}.")
 
 
 @constexpr
-def _check_axes_for_batch_dot(x1_shape, x2_shape, axes):
+def _check_axes_for_batch_dot(x1_shape, x2_shape, axes, prim_name=None):
     """
     Check whether axes are valid and cast axes from tuple to list
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if axes is None:
         if len(x2_shape) == 2:
             axes = [len(x1_shape) - 1, len(x2_shape) - 1]
@@ -441,9 +457,9 @@ def _check_axes_for_batch_dot(x1_shape, x2_shape, axes):
 
     if isinstance(axes, (list, tuple)):
         if 0 in axes:
-            raise ValueError("Batch dim cannot be used as in axes.")
+            raise ValueError(f"{msg_prefix} axes cannot contain 0, but got axes: {axes}.")
         if len(axes) != 2:
-            raise ValueError("Require two axes inputs, given less")
+            raise ValueError(f"{msg_prefix} length of axes must be equal to 2, but got {len(axes)}.")
         if isinstance(axes, tuple):
             axes = list(axes)
         validator.check_value_type('axes[0]', axes[0], [int], 'batch_dot')
@@ -456,22 +472,23 @@ def _check_axes_for_batch_dot(x1_shape, x2_shape, axes):
         validator.check_non_negative_int(axes[0], 'reversed axes[0]', 'batch_dot')
         validator.check_non_negative_int(axes[1], 'reversed axes[1]', 'batch_dot')
         if axes[0] > len(x1_shape) or axes[1] > len(x2_shape):
-            raise ValueError(
-                "Axes value too high for given input arrays dimensions.")
+            raise ValueError(f"{msg_prefix} axes[0] must be less than or equal to len(x1_shape), "
+                             f"and axes[1] must be less than or equal to len(x2_shape)."
+                             f"But got axes: {axes}, x1_shape: {x1_shape}, x2_shape: {x2_shape}.")
     elif isinstance(axes, int):
         if axes == 0:
-            raise ValueError("Batch dim cannot be used as in axes.")
+            raise ValueError(f"{msg_prefix} axes should not equal to 0, but got {axes}.")
         if axes < 0:
             axes = [axes + len(x1_shape), axes + len(x2_shape)]
             validator.check_non_negative_int(axes[0], 'reversed axes', 'batch_dot')
         elif axes > len(x1_shape) or axes > len(x2_shape):
-            raise ValueError(
-                "Axes value too high for given input arrays dimensions.")
+            raise ValueError(f"{msg_prefix} axes cannot be greater than the length of x1_shape and x2_shape, "
+                             f"but got axes: {axes}, x1_shape: {x1_shape}, x2_shape: {x2_shape}.")
         else:
             axes = [axes, axes]
     else:
-        raise ValueError(
-            "Axes type must be one of those: int, tuple(int), list(int).")
+        raise ValueError(f"{msg_prefix} type of axes must be one of those: int, tuple(int), list(int), "
+                         f"but got {type(axes)}.")
     return axes
 
 
@@ -496,12 +513,14 @@ def _calc_new_shape_batchdot(shape, axes, position=0):
 
 
 @constexpr
-def _check_batch_size(x1_batch_size, x2_batch_size):
+def _check_batch_size(x1_batch_size, x2_batch_size, prim_name=None):
     """
     Check whether batch size of two inputs are the same
     """
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if x1_batch_size != x2_batch_size:
-        raise ValueError("Require both inputs with the same batch sizes.")
+        raise ValueError(f"{msg_prefix} both inputs x1, x2 should have the same batch sizes, but got "
+                         f"x1_batch_size: {x1_batch_size} and x2_batch_size: {x2_batch_size}.")
 
 
 @constexpr
@@ -513,7 +532,7 @@ def _get_output_shape(batch_size, x1_ret, x2_ret):
     return output_shape
 
 
-def batch_dot(x1, x2, axes=None):
+def batch_dot(x1, x2, axes=None, prim_name=None):
     """
     Computation of batch dot product between samples in two tensors containing batch dims.
 
@@ -593,11 +612,11 @@ def batch_dot(x1, x2, axes=None):
     x1_type = F.dtype(x1)
     x2_type = F.dtype(x2)
 
-    x1_batch_size, x2_batch_size = _get_batch_size(x1_shape, x2_shape)
+    x1_batch_size, x2_batch_size = _get_batch_size(x1_shape, x2_shape, prim_name)
 
-    _typecheck_input_batch_dot(x1_type, x2_type)
-    _check_batch_size(x1_batch_size, x2_batch_size)
-    axes = _check_axes_for_batch_dot(x1_shape, x2_shape, axes)
+    _typecheck_input_batch_dot(x1_type, x2_type, prim_name)
+    _check_batch_size(x1_batch_size, x2_batch_size, prim_name)
+    axes = _check_axes_for_batch_dot(x1_shape, x2_shape, axes, prim_name)
 
     if x1_dim_num == 2:
         x1 = F.expand_dims(x1, 1)
@@ -664,19 +683,23 @@ def _infer_shape_rem(shape1, shape2, ndim1, ndim2, transpose_b):
 
 
 @constexpr
-def _check_matmul_shapes(shape1, shape2):
+def _check_matmul_shapes(shape1, shape2, prim_name=None):
     """Checks shape1 and shape2 are valid to perform matmul, and returns output shape after broadcasting."""
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     ndim1, ndim2 = len(shape1), len(shape2)
     if ndim1 < 1 or ndim2 < 1:
-        raise ValueError('input operands must have at least 1 dimension')
+        raise ValueError(f"{msg_prefix} dimension of input operands must be at least 1, but got "
+                         f"the length of shape1: {ndim1}, the length of shape2: {ndim2}.")
     if ndim2 >= 2 and shape1[-1] != shape2[-2]:
-        raise ValueError(f'mismatch in core dimension of input operands (size '
-                         f'{shape1[-1]} is different from {shape2[-2]})')
+        raise ValueError(f"{msg_prefix} shape1[-1] should be equal to shape2[-2] when the length of shape2 "
+                         f"is greater than or equal to 2, but got shape1[-1]: {shape1[-1]}, "
+                         f"shape2[-2]: {shape2[-2]}.")
     shape_out = deque()
     for items in zip_longest(reversed(shape1[:-2]), reversed(shape2[:-2]), fillvalue=1):
         max_size = max(items)
         if any(item not in (1, max_size) for item in items):
-            raise ValueError(f'operands could not be broadcast together with shapes {shape1} {shape2}')
+            raise ValueError(f"{msg_prefix} operands could not be broadcast together with shape1 {shape1} and "
+                             f"shape2 {shape2}.")
         shape_out.appendleft(max_size)
     return tuple(shape_out)
 
@@ -710,7 +733,7 @@ def _broadcast_to(x, shape_cur, shape_to, ndim_to):
     return F.tile(x, size)
 
 
-def matmul(x1, x2, dtype=None):
+def matmul(x1, x2, dtype=None, prim_name=None):
     """
     Returns the matrix product of two arrays.
 
@@ -775,7 +798,7 @@ def matmul(x1, x2, dtype=None):
     ndim1_orig, ndim2_orig = F.rank(x1), F.rank(x2)
     shape1_orig, shape2_orig = F.shape(x1), F.shape(x2)
     transpose_b = ndim2_orig == 1
-    shape_backbone = _check_matmul_shapes(shape1_orig, shape2_orig)
+    shape_backbone = _check_matmul_shapes(shape1_orig, shape2_orig, prim_name)
     # infers the shape of the output
     shape_out = shape_backbone + _infer_shape_rem(shape1_orig, shape2_orig,
                                                   ndim1_orig, ndim2_orig, transpose_b)

mindspore/ops/operations/comm_ops.py

@@ -81,12 +81,13 @@ class ReduceOp:
 target_dtypes = (mstype.int8, mstype.int32, mstype.float16, mstype.float32)
 
 
-def check_hcom_group_valid(group):
+def check_hcom_group_valid(group, prim_name=None):
     """Check if hcom group is valid."""
+    msg_pfefix = f"For '{prim_name}', only" if prim_name else "Only"
     if context.get_context("mode") == context.PYNATIVE_MODE and \
             context.get_context("device_target") == "Ascend" and \
             group != GlobalComm.WORLD_COMM_GROUP:
-        raise RuntimeError("Only hccl_world_group is supported in Pynative mode, but got {}".format(group))
+        raise RuntimeError(f"{msg_pfefix} hccl_world_group is supported in Pynative mode, but got 'group': {group}.")
 
 
 class AllReduce(PrimitiveWithInfer):
@@ -147,10 +148,11 @@ class AllReduce(PrimitiveWithInfer):
     def __init__(self, op=ReduceOp.SUM, group=GlobalComm.WORLD_COMM_GROUP):
         """Initialize AllReduce."""
         if not isinstance(op, type(ReduceOp.SUM)):
-            raise TypeError("The operation of AllReduce should be str.")
+            raise TypeError(f"For '{self.name}', the 'op' of AllReduce should be str, but got {type(op)}.")
         if not isinstance(_get_group(group), str):
-            raise TypeError("The group of AllReduce should be str.")
-        check_hcom_group_valid(group)
+            raise TypeError(f"For '{self.name}', the 'group' of AllReduce should be str, "
+                            f"but got {type(_get_group(group))}.")
+        check_hcom_group_valid(group, prim_name=self.name)
         self.op = op
         self.add_prim_attr('group', _get_group(group))
         self.add_prim_attr('fusion', 0)
@@ -339,7 +341,7 @@ class _HostAllGather(PrimitiveWithInfer):
     def __init__(self, group=None):
         """Initialize _HostAllGather."""
         if group is None:
-            raise ValueError(f"For '{self.name}' group must be set.")
+            raise ValueError(f"For '{self.name}', the 'group' cannot be None, but got {group}.")
         validator.check_value_type('group', group, (tuple, list), self.name)
         validator.check_int(len(group), 2, Rel.GE, "group size", self.name)
         for r in group:
@@ -426,9 +428,10 @@ class ReduceScatter(PrimitiveWithInfer):
 
     def infer_shape(self, x_shape):
         if self.rank_size == 0:
-            raise ValueError(f"For '{self.name}' rank_size can not be zero.")
+            raise ValueError(f"For '{self.name}', the 'rank_size' cannot be zero, but got {self.rank_size}.")
         if x_shape[0] % self.rank_size != 0:
-            raise ValueError(f"For '{self.name}' the first dimension of x should be divided by rank_size.")
+            raise ValueError(f"For '{self.name}', the first dimension of 'x_shape' should be divided by 'rank_size', "
+                             f"but got 'x_shape[0]': {x_shape[0]}, 'rank_size': {self.rank_size}.")
         x_shape[0] = int(x_shape[0] / self.rank_size)
         return x_shape
 
@@ -466,7 +469,7 @@ class _HostReduceScatter(PrimitiveWithInfer):
     def __init__(self, op=ReduceOp.SUM, group=None):
         """Initialize _HostReduceScatter."""
         if group is None:
-            raise ValueError(f"For '{self.name}' group must be set.")
+            raise ValueError(f"For '{self.name}', the 'group' cannot be None, but got {group}.")
         validator.check_value_type('op', op, (type(ReduceOp.SUM),), self.name)
         validator.check_value_type('group', group, (tuple, list), self.name)
         validator.check_int(len(group), 2, Rel.GE, "group size", self.name)
@@ -480,7 +483,8 @@ class _HostReduceScatter(PrimitiveWithInfer):
 
     def infer_shape(self, x_shape):
         if x_shape[0] % self.group_size != 0:
-            raise ValueError(f"For '{self.name}' the first dimension of x should be divided by group_size.")
+            raise ValueError(f"For '{self.name}', the first dimension of 'x_shape' should be divided by 'group_size', "
+                             f"but got 'x_shape[0]': {x_shape[0]}, 'rank_size': {self.group_size}.")
         x_shape[0] = int(x_shape[0] / self.group_size)
         return x_shape
 
@@ -551,7 +555,7 @@ class Broadcast(PrimitiveWithInfer):
         """Initialize Broadcast."""
         validator.check_value_type('root_rank', root_rank, (int,), self.name)
         validator.check_value_type('group', _get_group(group), (str,), self.name)
-        check_hcom_group_valid(group)
+        check_hcom_group_valid(group, prim_name=self.name)
         self.add_prim_attr('group', _get_group(group))
         self.add_prim_attr('no_elimilate', True)
 
@@ -560,7 +564,7 @@ class Broadcast(PrimitiveWithInfer):
 
     def infer_dtype(self, x_dtype):
         if not isinstance(x_dtype, tuple):
-            raise TypeError(f"{self.name}'s input should be a tuple!")
+            raise TypeError(f"For '{self.name}', the 'input_x' should be a tuple, but got {type(x_dtype)}!")
         for _ele in x_dtype:
             validator.check_tensor_dtype_valid('x', _ele, target_dtypes, self.name)
         return x_dtype
@@ -690,10 +694,11 @@ class AlltoAll(PrimitiveWithInfer):
     def infer_shape(self, x_shape):
         rank_size = get_group_size(_get_group(self.group))
         if self.split_count != rank_size:
-            raise ValueError(f"split count '{self.split_count}' must be equal to rank size '{rank_size}'.")
+            raise ValueError(f"For '{self.name}', the 'split_count' must be equal to 'rank_size', "
+                             f"but got 'split_count': {self.split_count}, 'rank_size': {rank_size}.")
         if x_shape[self.split_dim] % self.split_count != 0:
-            raise ValueError(
-                f"split count '{self.split_count}' must be divisible by rank size '{x_shape[self.split_dim]}'.")
+            raise ValueError(f"For '{self.name}', the 'split_count' must be divisible by 'rank_size', "
+                             f"but got 'split_count' {self.split_count}, 'rank_size' {x_shape[self.split_dim]}.")
         x_shape[self.concat_dim] = x_shape[self.concat_dim] * self.split_count
         x_shape[self.split_dim] = int(x_shape[self.split_dim] / self.split_count)
         return x_shape

mindspore/ops/operations/debug_ops.py

@@ -27,7 +27,7 @@ def _check_mode(class_name):
     """Check for PyNative mode."""
     mode = context.get_context('mode')
     if mode == context.PYNATIVE_MODE:
-        raise RuntimeError(f'{class_name} operator does not support PyNative mode.')
+        raise RuntimeError(f"For '{class_name}', the operator does not support PyNative mode.")
 
 
 def _check_summary_param(name, value, class_name):
@@ -37,7 +37,7 @@ def _check_summary_param(name, value, class_name):
     n_value = name['value']
     validator.check_value_type('name', n_type, [type(mstype.string)], class_name)
     if not n_value:
-        raise ValueError(f"For 'name' the value should by valid string in {class_name}, but got an empty string.")
+        raise ValueError(f"For '{class_name}', the name should be valid string, but got '{n_value}'.")
 
     v_type = value['dtype']
     validator.check_value_type('value', v_type, [type(mstype.tensor)], class_name)
@@ -135,7 +135,7 @@ class ImageSummary(PrimitiveWithInfer):
         v_shape = value['shape']
         image_dim = 4
         if len(v_shape) != image_dim:
-            raise ValueError(f"For 'value' the dim should be {image_dim} in {self.__class__.__name__},"
+            raise ValueError(f"For '{self.name}', the dimension of 'value' should be {image_dim},"
                              f" but got {len(v_shape)}.")
 
         return SUMMARY_RETURN_VALUE
@@ -226,8 +226,8 @@ class HistogramSummary(PrimitiveWithInfer):
         v_shape = value['shape']
         # In the summary, the histogram value should be a tensor whose shape is not [].
         if not v_shape:
-            raise ValueError(f"For 'value' the type should be tensor in {self.__class__.__name__}, "
-                             f"shape should not be [].")
+            raise ValueError(f"For '{self.name}', the type of 'value' should be tensor, "
+                             f"and whose shape should not be [], but got {v_shape}.")
 
         return SUMMARY_RETURN_VALUE
 
@@ -343,7 +343,8 @@ class HookBackward(PrimitiveWithInfer):
         self.add_prim_attr("cell_id", cell_id)
         self.init_attrs["cell_id"] = cell_id
         if not isinstance(hook_fn, (FunctionType, MethodType)):
-            raise TypeError("Hook function should be python function type.")
+            raise TypeError(f"For '{self.name}', the tye of 'hook_fn' should be python function, "
+                            f"but got {type(hook_fn)}.")
         self.register_hook(hook_fn)
         self.cell_id = cell_id
 

mindspore/ops/operations/image_ops.py

@@ -104,7 +104,7 @@ class CropAndResize(PrimitiveWithInfer):
         box_index_shape = list(box_index['shape'])
         # get value
         if crop_size['value'] is None:
-            raise ValueError(f"For {self.name}, crop_size must be constant.")
+            raise ValueError(f"For '{self.name}', the 'crop_size' cannot be None, but got {crop_size['value']}.")
         crop_size_value = crop_size['value']
         # get dtype
         x_dtype = x['dtype']

mindspore/ops/operations/math_ops.py

@@ -389,7 +389,7 @@ class _Reduce(PrimitiveWithInfer):
         args = {'input_x': input_x['dtype']}
         validator.check_tensors_dtypes_same_and_valid(args, valid_dtype, self.name)
         if not isinstance(axis, mstype.tensor_type) and axis_v is None:
-            raise ValueError(f"For {self.name}, axis must be const.")
+            raise ValueError(f"For '{self.name}', the 'axis' cannot be None, but got {axis}.")
         out_shape = _infer_shape_reduce(input_shp, axis_v, self.keep_dims, self.name)
         if -1 in input_shp:
             if axis_v is None:
@@ -399,7 +399,8 @@ class _Reduce(PrimitiveWithInfer):
                     max_v = max(input_max_shp)
                 axis_shape_list = axis['shape']
                 if len(axis_shape_list) != 1:
-                    raise ValueError("axis_shape must be 1-D, but got ", len(axis_shape_list))
+                    raise ValueError(f"For '{self.name}', the shape of 'axis' must be 1-D, but "
+                                     f"got {len(axis_shape_list)}.")
                 axis_shape = axis_shape_list[0]
                 if len(axis_shape) == 1 and axis_shape[0] == -1 and not self.keep_dims:
                     out_shape = np.array([-2]).tolist()
@@ -1047,7 +1048,7 @@ class CumProd(PrimitiveWithInfer):
 
     def infer_value(self, x, axis):
         if axis is None:
-            raise ValueError(f"For {self.name}, axis must be const.")
+            raise ValueError(f"For '{self.name}', the 'axis' cannot be None, but got {axis}.")
 
 
 class MatMul(PrimitiveWithCheck):
@@ -1102,8 +1103,8 @@ class MatMul(PrimitiveWithCheck):
     def check_shape_size(self, x1, x2):
         """Check the shape size of inputs for MatMul."""
         if len(x1) != 2 or len(x2) != 2:
-            raise ValueError('P.MatMul inputs x1, x2 should have the same dimension size and '
-                             + f'equal to 2, while x1 size is ({len(x1)}) and x2 size is ({len(x2)}).')
+            raise ValueError(f"For '{self.name}', inputs 'x', 'y' should have the same dimension size and "
+                             f"be equal to 2, but got the size of 'x': ({len(x1)}) and the size of 'y': ({len(x2)}).")
 
     def check_shape(self, x1, x2):
         self.check_shape_size(x1, x2)
@@ -1111,8 +1112,8 @@ class MatMul(PrimitiveWithCheck):
         # expected dimension of x, y, x:[...,a,b] y:[..., c,d], the dim size should be the same except the last two
         for i in range(len(x1) - 2):
             if x1[i] != x2[i]:
-                raise ValueError(f'For \'{cls_name}\' shape in dim[{i}] not the same, '
-                                 + f'while x1 is {x1[i]}, x2 is {x2[i]}')
+                raise ValueError(f"For '{cls_name}', the dim[{i}] of 'x' should be equal to the dim[{i}] of 'y', "
+                                 f"but got 'x[{i}]': {x1[i]} and 'y[{i}]': {x2[i]}.")
 
         # validate whether last two dims satisfying matrix multiply
         x1_last = x1[-2:]
@@ -1121,10 +1122,9 @@ class MatMul(PrimitiveWithCheck):
         x2_row = x2_last[self.transpose_b]
         if np.all(np.array(x1) != -1) and np.all(np.array(x2) != -1):
             if x1_col != x2_row:
-                raise ValueError(f'For \'{cls_name}\' evaluator shapes of inputs can not do this operator,'
-                                 f' dimensions must be equal,'
-                                 + f' got {x1_col} and {x2_row}, with x1 shape {x1}(transpose_a={self.transpose_a})'
-                                 + f', x2 shape {x2}(transpose_b={self.transpose_b}).')
+                raise ValueError(f"For '{cls_name}', the input dimensions must be equal, but got 'x1_col': {x1_col} "
+                                 f"and 'x2_row': {x2_row}. And 'x' shape {x1}(transpose_a={self.transpose_a}), "
+                                 f"'y' shape {x2}(transpose_b={self.transpose_b}).")
         # set attribute
         self.add_prim_attr('transpose_x1', self.transpose_a)
         self.add_prim_attr('transpose_x2', self.transpose_b)
@@ -1207,8 +1207,8 @@ class BatchMatMul(MatMul):
 
     def check_shape_size(self, x, y):
         if len(x) != len(y) or len(x) < 3:
-            raise ValueError('For \'BatchMatMul\' input x, y should be the same dimension size and should be '
-                             'greater or equal to 3,' + f' while x size = {len(x)}, y size= {len(y)}')
+            raise ValueError(f"For '{self.name}', input 'x', 'y' should be the same dimension size and should be "
+                             f"greater than or equal to 3, but got 'x' size: {len(x)}, 'y' size: {len(y)}.")
 
 
 class CumSum(PrimitiveWithInfer):
@@ -1286,7 +1286,7 @@ class CumSum(PrimitiveWithInfer):
         cls_name = self.name
         x_shp = x['shape']
         if axis['value'] is None:
-            raise ValueError(f"For {self.name}, axis must be const.")
+            raise ValueError(f"For '{self.name}', the 'axis' cannot be None, but got {axis}.")
         validator.check_value_type('axis', axis['value'], [int], cls_name)
         valid_dtypes = [mstype.uint8, mstype.int8, mstype.int32, mstype.float16, mstype.float32, mstype.float64]
         validator.check_tensor_dtype_valid('x', x['dtype'], valid_dtypes, cls_name)
@@ -1341,7 +1341,9 @@ class AddN(Primitive):
             return False, None
         if isinstance(inputs[0], Tensor):
             return True, inputs[0]
-        raise TypeError("Expecting Tensor, got : {}".format(type(inputs[0])))
+        raise TypeError(f"For '{self.name}', the type of 'inputs[0]' should be a tensor, but "
+                        f"got {type(inputs[0]).__name__}, "
+                        f"or the length of 'inputs' should not equal to 1, but got ({len(inputs)}).")
 
 
 class AccumulateNV2(PrimitiveWithInfer):
@@ -1395,7 +1397,9 @@ class AccumulateNV2(PrimitiveWithInfer):
             return False, None
         if isinstance(inputs[0], Tensor):
             return True, inputs[0]
-        raise TypeError("Expecting Tensor, got : {}".format(type(inputs[0])))
+        raise TypeError(f"For '{self.name}', the type of 'inputs[0]' should be a tensor, "
+                        f"but got {type(inputs[0]).__name__}, "
+                        f"or the length of 'inputs' should not equal to 1, but got ({len(inputs)}).")
 
     def infer_shape(self, inputs):
         cls_name = self.name
@@ -1527,7 +1531,8 @@ class InplaceAdd(PrimitiveWithInfer):
                         Rel.EQ, self.name)
         for i in self.indices:
             if i < 0 or i >= x_shape[0]:
-                raise ValueError(f'The value of indices must be in [0, {x_shape[0]}), but got {i}.')
+                raise ValueError(f"For '{self.name}', the value of 'indices' must be "
+                                 f"in [0, {x_shape[0]}), but got {i}.")
         x_rank = len(x_shape)
         for idx in range(x_rank)[1:]:
             validator.check('v dim %d' % idx, v_shape[idx], "x dim %d" % idx, x_shape[idx], Rel.EQ, self.name)
@@ -1595,7 +1600,8 @@ class InplaceSub(PrimitiveWithInfer):
                         Rel.EQ, self.name)
         for i in self.indices:
             if i < 0 or i >= x_shape[0]:
-                raise ValueError(f'The value of indices must be in [0, {x_shape[0]}), but got {i}.')
+                raise ValueError(f"For '{self.name}', the value of 'indices' must be "
+                                 f"in [0, {x_shape[0]}), but got {i}.")
         x_rank = len(x_shape)
         for idx in range(x_rank)[1:]:
             validator.check('v dim %d' % idx, v_shape[idx], "x dim %d" % idx, x_shape[idx], Rel.EQ, self.name)

mindspore/ops/operations/other_ops.py

@@ -380,7 +380,7 @@ class IOU(PrimitiveWithInfer):
     def __init__(self, mode='iou'):
         """Initialize IOU."""
         if mode not in {'iou', 'iof'}:
-            raise KeyError("Mode only support 'iou' or 'iof'.")
+            raise KeyError(f"For '{self.name}', only 'iou' or 'iof' are supported, but got 'mode': {mode}.")
         self.init_prim_io_names(inputs=['anchor_boxes', 'gt_boxes'], outputs=['overlap'])
 
     def infer_shape(self, anchor_boxes, gt_boxes):
@@ -535,12 +535,11 @@ class CheckBprop(PrimitiveWithInfer):
         self.prim_to_check = prim_to_check
 
     def infer_shape(self, xshapes, yshapes):
-        tips = f'Bprop of {self.prim_to_check}'
-        validator.check_value_type('grads', xshapes, (tuple,), tips)
-        validator.check_value_type('params', yshapes, (tuple,), tips)
+        validator.check_value_type('grads', xshapes, (tuple,), self.name)
+        validator.check_value_type('params', yshapes, (tuple,), self.name)
         if len(xshapes) < len(yshapes):
-            raise ValueError(f"{tips}, the size of output should be {len(yshapes)},"
-                             f" but got {len(xshapes)}.")
+            raise ValueError(f"For '{self.name}', the size of 'xshapes' should not be less than {len(yshapes)}, "
+                             f"but got {len(xshapes)}.")
         checking_range = len(yshapes)
         for i in range(checking_range):
             xshape = xshapes[i]
@@ -548,16 +547,15 @@ class CheckBprop(PrimitiveWithInfer):
             if not xshape or not yshape:
                 continue
             if xshape != yshape:
-                raise ValueError(f"{tips}, the shape of {i}th output should be {yshape},"
-                                 f" but got {xshape}.")
+                raise ValueError(f"For '{self.name}', the shape of {i}th 'xshapes' should be {yshape},"
+                                 f" but got 'xshapes[i]': {xshape}.")
         return xshapes
 
     def infer_dtype(self, xdtypes, ydtypes):
-        tips = f'Bprop of {self.prim_to_check}'
-        validator.check_value_type('grads', xdtypes, (tuple,), tips)
-        validator.check_value_type('params', ydtypes, (tuple,), tips)
+        validator.check_value_type('grads', xdtypes, (tuple,), self.name)
+        validator.check_value_type('params', ydtypes, (tuple,), self.name)
         if len(xdtypes) < len(ydtypes):
-            raise ValueError(f"{tips}, the size of output should be {len(ydtypes)},"
+            raise ValueError(f"For '{self.name}', the size of 'xdtypes' should not be less than {len(ydtypes)},"
                              f" but got {len(xdtypes)}.")
         checking_range = len(ydtypes)
         for i in range(checking_range):
@@ -567,11 +565,11 @@ class CheckBprop(PrimitiveWithInfer):
                 continue
             if isinstance(ydtype, mstype.function_type):
                 if not isinstance(xdtype, mstype.env_type_type):
-                    raise TypeError(f"{tips}, the dtype of {i}th output should be {mstype.env_type_type},"
+                    raise TypeError(f"For '{self.name}', the dtype of {i}th 'xdtypes' should be {mstype.env_type_type},"
                                     f" but got {xdtype}.")
                 continue
             if xdtype != ydtype:
-                raise TypeError(f"{tips}, the dtype of {i}th output should be {ydtype},"
+                raise TypeError(f"For '{self.name}', the shape of {i}th 'xdtypes' should be {ydtype},"
                                 f" but got {xdtype}.")
         return xdtypes
 

mindspore/ops/operations/quantum_ops.py

@@ -64,13 +64,11 @@ class PQC(PrimitiveWithInfer):
 
     def check_shape_size(self, encoder_data, ansatz_data):
         if len(encoder_data) != 2:
-            raise ValueError(
-                "PQC input encoder_data should have dimension size \
-equal to 2, but got {}.".format(len(encoder_data)))
+            raise ValueError(f"For '{self.name}', the dimension of 'encoder_data' should be 2, "
+                             f"but got {len(encoder_data)}.")
         if len(ansatz_data) != 1:
-            raise ValueError(
-                "PQC input ansatz_data should have dimension size \
-equal to 1, but got {}.".format(len(ansatz_data)))
+            raise ValueError(f"For '{self.name}', the dimension of 'ansatz_data' should be 1, "
+                             f"but got {len(ansatz_data)}.")
 
     def infer_shape(self, encoder_data, ansatz_data):
         self.check_shape_size(encoder_data, ansatz_data)
@@ -124,8 +122,8 @@ class Evolution(PrimitiveWithInfer):
 
     def check_shape_size(self, param_data):
         if len(param_data) != 1:
-            raise ValueError("PQC input param_data should have dimension size \
-equal to 1, but got {}.".format(len(param_data)))
+            raise ValueError(f"For '{self.name}', the dimension of 'param_data' should be 1, "
+                             f"but got {len(param_data)}.")
 
     def infer_shape(self, param_data):
         self.check_shape_size(param_data)

mindspore/ops/operations/random_ops.py

@@ -69,7 +69,7 @@ class StandardNormal(PrimitiveWithInfer):
     def __infer__(self, shape):
         shape_v = shape["value"]
         if shape_v is None:
-            raise ValueError(f"For {self.name}, shape must be const.")
+            raise ValueError(f"For '{self.name}', the 'shape' cannot be None, but got {shape}.")
         Validator.check_value_type("shape", shape_v, [tuple], self.name)
         for i, shape_i in enumerate(shape_v):
             Validator.check_positive_int(shape_i, f'shape[{i}]', self.name)
@@ -126,7 +126,7 @@ class StandardLaplace(PrimitiveWithInfer):
     def __infer__(self, shape):
         shape_v = shape["value"]
         if shape_v is None:
-            raise ValueError(f"For {self.name}, shape must be const.")
+            raise ValueError(f"For '{self.name}', the 'shape' cannot be None, but got {shape}.")
         Validator.check_value_type("shape", shape_v, [tuple], self.name)
         for i, shape_i in enumerate(shape_v):
             Validator.check_positive_int(shape_i, f'shape[{i}]', self.name)
@@ -189,7 +189,7 @@ class Gamma(PrimitiveWithInfer):
     def __infer__(self, shape, alpha, beta):
         shape_v = shape["value"]
         if shape_v is None:
-            raise ValueError(f"For {self.name}, shape must be const.")
+            raise ValueError(f"For '{self.name}', the 'shape' cannot be None, but got {shape}.")
         Validator.check_value_type("shape", shape_v, [tuple], self.name)
         for i, shape_i in enumerate(shape_v):
             Validator.check_positive_int(shape_i, f'shape[{i}]', self.name)
@@ -253,7 +253,7 @@ class Poisson(PrimitiveWithInfer):
     def __infer__(self, shape, mean):
         shape_v = shape["value"]
         if shape_v is None:
-            raise ValueError(f"For {self.name}, shape must be const.")
+            raise ValueError(f"For '{self.name}', the 'shape' cannot be None, but got {shape}.")
         Validator.check_value_type("shape", shape_v, [tuple], self.name)
         for i, shape_i in enumerate(shape_v):
             Validator.check_positive_int(shape_i, f'shape[{i}]', self.name)
@@ -325,7 +325,7 @@ class UniformInt(PrimitiveWithInfer):
     def __infer__(self, shape, minval, maxval):
         shape_v = shape["value"]
         if shape_v is None:
-            raise ValueError(f"For {self.name}, shape must be const.")
+            raise ValueError(f"For '{self.name}', the 'shape' cannot be None, but got {shape}.")
         Validator.check_value_type("shape", shape_v, [tuple], self.name)
         for i, shape_i in enumerate(shape_v):
             Validator.check_positive_int(shape_i, f'shape[{i}]', self.name)
@@ -500,7 +500,8 @@ class RandomCategorical(PrimitiveWithInfer):
         Validator.check_positive_int(num_samples_v, "num_samples", self.name)
         x_shape = list(logits['shape'])
         if len(x_shape) != 2:
-            raise ValueError("RandomCategorical shape should be 2-dimension.")
+            raise ValueError(f"For '{self.name}', the shape of 'logits' should be 2-dimension, "
+                             f"but got {len(x_shape)}.")
         ndim = len(x_shape) - 1
         x_shape[ndim] = num_samples_v
         self.add_prim_attr('num_samples', num_samples_v)
@@ -558,11 +559,12 @@ class Multinomial(PrimitiveWithInfer):
     def __infer__(self, inputs, num_samples):
         input_shape = inputs["shape"]
         if len(input_shape) != 1 and len(input_shape) != 2:
-            raise ValueError("input dim must be 1 or 2")
+            raise ValueError(f"For '{self.name}', the dimension of 'inputs' must be 1 or 2, "
+                             f"but got {len(input_shape)}.")
         Validator.check_tensor_dtype_valid('inputs', inputs['dtype'], [mstype.float32], self.name)
         num_samples_value = num_samples["value"]
         if num_samples_value is None:
-            raise ValueError(f"For {self.name}, shape nust be const")
+            raise ValueError(f"For '{self.name}', the 'num_samples' cannot be None, but got {num_samples}.")
         Validator.check_value_type("num_samples", num_samples_value, (int,), self.name)
         Validator.check_positive_int(num_samples_value, "num_samples")
         y_shape = (num_samples_value,)

mindspore/ops/operations/rl_ops.py

@@ -206,20 +206,27 @@ class BufferAppend(PrimitiveWithInfer):
             exp_batch = exp_shape[0][0]
             for i in range(len(data_shape)):
                 if len(data_shape[i]) != len(exp_shape[i]):
-                    raise ValueError(f'For {self.name}, exp shape size must equal to buffer')
+                    raise ValueError(f"For '{self.name}', the dimension of {i}th 'exp_shape' must equal to "
+                                     f"the dimension of {i}th 'data_shape', but got the {i}th 'exp_shape': "
+                                     f"{exp_shape[i]}, the {i}th 'data_shape': {data_shape[i]}.")
                 if data_shape[i][0] < exp_shape[i][0]:
-                    raise ValueError(f'For {self.name}, exp batch size must lessequal than buffer')
+                    raise ValueError(f"For '{self.name}', the first dimension of {i}th 'data_shape' must be greater "
+                                     f"than or equal to the first dimension of {i}th 'exp_shape', but got the {i}th "
+                                     f"'exp_shape': {exp_shape[i]}, the {i}th 'data_shape': {data_shape[i]}.")
         else:
             for i in range(len(data_shape)):
                 if data_shape[i][1:] != exp_shape[i]:
-                    raise ValueError(f'For {self.name}, exp shape must equal to one of buffer shape')
+                    raise ValueError(f"For '{self.name}', the {i}th 'exp_shape' must equal to the {i}th 'data_shape'"
+                                     f"which excepts the first dimension. but got the {i}th 'exp_shape': "
+                                     f"{exp_shape[i]}, the {i}th 'data_shape': {data_shape[i]}.")
         self.add_prim_attr('exp_batch', exp_batch)
         return count_shape
 
     def infer_dtype(self, data_type, exp_type, count_type, head_type):
         for i in range(len(data_type)):
             if data_type[i] != exp_type[i]:
-                raise TypeError(f'For {self.name}, each tensor in exp must has the same type with buffer')
+                raise TypeError(f"For '{self.name}', each tensor in 'exp' must has the same type with 'data', but got "
+                                f"'data_type': {data_type}, 'exp_type': {exp_type}.")
         validator.check_type_name("count type", count_type, (mstype.int32), self.name)
         validator.check_type_name("head type", head_type, (mstype.int32), self.name)
         return count_type

mindspore/ops/operations/sparse_ops.py

@@ -67,22 +67,22 @@ class SparseToDense(PrimitiveWithInfer):
         validator.check_tensor_dtype_valid('values', values['dtype'], mstype.number_type + (mstype.bool_,), self.name)
         indices_shape = indices['shape']
         if len(indices_shape) != 2:
-            raise ValueError("SparseToDense requires 'indices' must be a 2-D Tensor, "
-                             f"but got 'indices' shape: {indices_shape}")
+            raise ValueError(f"For '{self.name}', the 'indices' must be a 2-D tensor, "
+                             f"but got 'indices' shape: {indices_shape}.")
         values_shape = values['shape']
         if len(values_shape) != 1 or values_shape[0] != indices_shape[0]:
-            raise ValueError("SparseToDense requires 'values' must be a 1-D Tensor and "
-                             "the first dimension length must be equal to the first dimension length of 'indices', "
-                             f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}")
+            raise ValueError(f"For '{self.name}', the 'values' must be a 1-D tensor and the first dimension length "
+                             f"must be equal to the first dimension length of 'indices', "
+                             f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}.")
         sparse_shape_v = sparse_shape['value']
         for i in sparse_shape_v:
             if isinstance(i, bool) or not isinstance(i, int) or i <= 0:
-                raise ValueError("SparseToDense requires all elements in 'sparse_shape' must be "
-                                 f"positive int number, but got 'sparse_shape': {sparse_shape_v}")
+                raise ValueError(f"For '{self.name}', all elements in 'sparse_shape' must be "
+                                 f"positive int number, but got 'sparse_shape': {sparse_shape_v}.")
         if len(sparse_shape_v) != indices_shape[1]:
-            raise ValueError("SparseToDense requires the 'sparse_shape' length should be equal to the 'indices' "
-                             "second dimension length, but got the 'indices' second dimension length: "
-                             f"{indices_shape[1]}, 'sparse_shape' length: {len(sparse_shape_v)}")
+            raise ValueError(f"For '{self.name}', the length of 'sparse_shape' should be equal to the second dimension "
+                             f"length of 'indices', but got the second dimension length of 'indices': "
+                             f"{indices_shape[1]}, length of 'sparse_shape': {len(sparse_shape_v)}.")
         out = {'shape': sparse_shape['value'],
                'dtype': values['dtype'],
                'value': None}
@@ -157,26 +157,29 @@ class SparseTensorDenseMatmul(PrimitiveWithInfer):
         validator.check_tensors_dtypes_same_and_valid(args, valid_types, self.name)
         indices_shape = indices['shape']
         if len(indices_shape) != 2 or indices_shape[1] != 2:
-            raise ValueError("SparseTensorDenseMatmul requires 'indices' must be a 2-D Tensor and "
-                             f"the second dimension length must be 2, but got 'indices' shape: {indices_shape}")
+            raise ValueError(f"For '{self.name}', the 'indices' must be a 2-D tensor and "
+                             f"the second dimension length must be 2, but got 'indices' shape: {indices_shape}.")
         values_shape = values['shape']
         if len(values_shape) != 1 or values_shape[0] != indices_shape[0]:
-            raise ValueError("SparseTensorDenseMatmul requires 'value's must be a 1-D Tensor and "
+            raise ValueError(f"For '{self.name}', the 'values' must be a 1-D tensor and "
                              f"the first dimension length must be equal to the first dimension length of 'indices', "
-                             f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}")
+                             f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}.")
         a_shape = sparse_shape['value'][::-1] if self.adjoint_st else sparse_shape['value']
         b_shape = dense['shape'][::-1] if self.adjoint_dt else dense['shape']
         for i in a_shape:
             if isinstance(i, bool) or not isinstance(i, int) or i <= 0:
-                raise ValueError("SparseTensorDenseMatmul requires all elements in 'sparse_shape' must be "
-                                 f"positive int number, but got sparse shape: {a_shape}")
+                raise ValueError(f"For '{self.name}', all elements in 'sparse_shape' must be "
+                                 f"positive int number, but got 'sparse_shape': {a_shape}.")
         if len(a_shape) != 2 or len(b_shape) != 2:
-            raise ValueError("SparseTensorDenseMatmul requires both the 'sparse_shape' length and the dense tensor "
-                             f"rank should be equal to 2, but got 'sparse_shape' length: {len(a_shape)}, "
-                             f"dense tensor rank: {len(b_shape)}")
+            raise ValueError(f"For '{self.name}', both the length of 'sparse_shape' and the tensor "
+                             f"rank of 'dense' should be equal to 2, but got the length of "
+                             f"'sparse_shape': {len(a_shape)}, "
+                             f"the tensor rank of 'dense': {len(b_shape)}.")
         if a_shape[1] != b_shape[0]:
-            raise ValueError(f"The sparse tensor shape: {a_shape} and the dense tensor shape: {b_shape} "
-                             f"don't meet the condition for matmul")
+            raise ValueError(f"For '{self.name}', the second dimension length of 'sparse_shape' must be equal to the "
+                             f"first dimension length of 'dense', but got "
+                             f"the tensor shape of 'sparse': {a_shape} and the tensor shape of 'dense': {b_shape}. "
+                             f"Don't meet the condition for matmul")
         out_shape = [a_shape[0], b_shape[1]]
         out = {'shape': tuple(out_shape),
                'dtype': values['dtype'],

mindspore/ops/operations/sponge_ops.py

@@ -2329,7 +2329,6 @@ class LJEnergy(PrimitiveWithInfer):
         validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(nl_numbers), 1, Rel.EQ, "nl_numbers_dim", cls_name)
         validator.check_int(len(nl_serial), 2, Rel.EQ, "nl_serial_dim", cls_name)
-        validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(d_lj_b), 1, Rel.EQ, "d_LJ_B_dim", cls_name)
 
         validator.check_int(uint_crd[0], n, Rel.EQ, "uint_crd_shape[0]", cls_name)
@@ -2340,7 +2339,6 @@ class LJEnergy(PrimitiveWithInfer):
         validator.check_int(nl_numbers[0], n, Rel.EQ, "nl_numbers_shape", cls_name)
         validator.check_int(nl_serial[0], n, Rel.EQ, "nl_serial_shape[0]", cls_name)
         validator.check_int(nl_serial[1], 800, Rel.LE, "nl_serial_shape[1]", cls_name)
-        validator.check_int(scaler[0], 3, Rel.EQ, "scaler_shape", cls_name)
         validator.check_int(d_lj_b[0], q, Rel.EQ, "d_LJ_B_shape[0]", cls_name)
         return charge
 
@@ -2421,7 +2419,6 @@ class LJForce(PrimitiveWithInfer):
         validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(nl_numbers), 1, Rel.EQ, "nl_numbers_dim", cls_name)
         validator.check_int(len(nl_serial), 2, Rel.EQ, "nl_serial_dim", cls_name)
-        validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(d_lj_b), 1, Rel.EQ, "d_LJ_B_dim", cls_name)
 
         validator.check_int(uint_crd[0], n, Rel.EQ, "uint_crd_shape[0]", cls_name)
@@ -2432,7 +2429,6 @@ class LJForce(PrimitiveWithInfer):
         validator.check_int(nl_numbers[0], n, Rel.EQ, "nl_numbers_shape", cls_name)
         validator.check_int(nl_serial[0], n, Rel.EQ, "nl_serial_shape[0]", cls_name)
         validator.check_int(nl_serial[1], 800, Rel.LE, "nl_serial_shape[1]", cls_name)
-        validator.check_int(scaler[0], 3, Rel.EQ, "scaler_shape", cls_name)
         validator.check_int(d_lj_b[0], q, Rel.EQ, "d_LJ_B_shape[0]", cls_name)
         return uint_crd
 
@@ -2517,7 +2513,6 @@ class LJForceWithPMEDirectForce(PrimitiveWithInfer):
         validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(nl_numbers), 1, Rel.EQ, "nl_numbers_dim", cls_name)
         validator.check_int(len(nl_serial), 2, Rel.EQ, "nl_serial_dim", cls_name)
-        validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(d_lj_b), 1, Rel.EQ, "d_LJ_B_dim", cls_name)
 
         validator.check_int(uint_crd[0], n, Rel.EQ, "uint_crd_shape[0]", cls_name)
@@ -2528,7 +2523,6 @@ class LJForceWithPMEDirectForce(PrimitiveWithInfer):
         validator.check_int(nl_numbers[0], n, Rel.EQ, "nl_numbers_shape", cls_name)
         validator.check_int(nl_serial[0], n, Rel.EQ, "nl_serial_shape[0]", cls_name)
         validator.check_int(nl_serial[1], 800, Rel.EQ, "nl_serial_shape[1]", cls_name)
-        validator.check_int(scaler[0], 3, Rel.EQ, "scaler_shape", cls_name)
         validator.check_int(d_lj_b[0], q, Rel.EQ, "d_LJ_B_shape[0]", cls_name)
         return uint_crd
 

mindspore/ops/operations/sponge_update_ops.py

@@ -1392,7 +1392,6 @@ class LJForceWithVirialEnergy(PrimitiveWithInfer):
         validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(nl_numbers), 1, Rel.EQ, "nl_numbers_dim", cls_name)
         validator.check_int(len(nl_serial), 2, Rel.EQ, "nl_serial_dim", cls_name)
-        validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(d_lj_b), 1, Rel.EQ, "d_LJ_B_dim", cls_name)
 
         validator.check_int(uint_crd[0], n, Rel.EQ, "uint_crd_shape[0]", cls_name)
@@ -1403,7 +1402,6 @@ class LJForceWithVirialEnergy(PrimitiveWithInfer):
         validator.check_int(nl_numbers[0], n, Rel.EQ, "nl_numbers_shape", cls_name)
         validator.check_int(nl_serial[0], n, Rel.EQ, "nl_serial_shape[0]", cls_name)
         validator.check_int(nl_serial[1], 800, Rel.EQ, "nl_serial_shape[1]", cls_name)
-        validator.check_int(scaler[0], 3, Rel.EQ, "scaler_shape", cls_name)
         validator.check_int(d_lj_b[0], q, Rel.EQ, "d_LJ_B_shape[0]", cls_name)
         return [n, 3], [n,], [n,]
 
@@ -1494,7 +1492,6 @@ class LJForceWithPMEDirectForceUpdate(PrimitiveWithInfer):
         validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(nl_numbers), 1, Rel.EQ, "nl_numbers_dim", cls_name)
         validator.check_int(len(nl_serial), 2, Rel.EQ, "nl_serial_dim", cls_name)
-        validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(d_lj_b), 1, Rel.EQ, "d_LJ_B_dim", cls_name)
 
         validator.check_int(uint_crd[0], n, Rel.EQ, "uint_crd_shape[0]", cls_name)
@@ -1505,7 +1502,6 @@ class LJForceWithPMEDirectForceUpdate(PrimitiveWithInfer):
         validator.check_int(nl_numbers[0], n, Rel.EQ, "nl_numbers_shape", cls_name)
         validator.check_int(nl_serial[0], n, Rel.EQ, "nl_serial_shape[0]", cls_name)
         validator.check_int(nl_serial[1], 800, Rel.EQ, "nl_serial_shape[1]", cls_name)
-        validator.check_int(scaler[0], 3, Rel.EQ, "scaler_shape", cls_name)
         validator.check_int(d_lj_b[0], q, Rel.EQ, "d_LJ_B_shape[0]", cls_name)
         return [n, 3]
 
@@ -1798,7 +1794,6 @@ class LJForceWithVirialEnergyUpdate(PrimitiveWithInfer):
         validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(nl_numbers), 1, Rel.EQ, "nl_numbers_dim", cls_name)
         validator.check_int(len(nl_serial), 2, Rel.EQ, "nl_serial_dim", cls_name)
-        validator.check_int(len(scaler), 1, Rel.EQ, "scaler_dim", cls_name)
         validator.check_int(len(d_lj_b), 1, Rel.EQ, "d_LJ_B_dim", cls_name)
 
         validator.check_int(uint_crd[0], n, Rel.EQ, "uint_crd_shape[0]", cls_name)
@@ -1809,7 +1804,6 @@ class LJForceWithVirialEnergyUpdate(PrimitiveWithInfer):
         validator.check_int(nl_numbers[0], n, Rel.EQ, "nl_numbers_shape", cls_name)
         validator.check_int(nl_serial[0], n, Rel.EQ, "nl_serial_shape[0]", cls_name)
         validator.check_int(nl_serial[1], 800, Rel.EQ, "nl_serial_shape[1]", cls_name)
-        validator.check_int(scaler[0], 3, Rel.EQ, "scaler_shape", cls_name)
         validator.check_int(d_lj_b[0], q, Rel.EQ, "d_LJ_B_shape[0]", cls_name)
         return [n, 3], [n,], [n,]
 

tests/ut/python/nn/test_resizebilinear.py

@@ -90,7 +90,7 @@ def test_resizebilinear_error():
     net = Net()
     with pytest.raises(ValueError) as ex:
         net()
-    assert "size and scale both none" in str(ex.value)
+    assert "'size' and 'scale' both none" in str(ex.value)
 
 
 def test_resizebilinear_error_1():
@@ -106,4 +106,4 @@ def test_resizebilinear_error_1():
     net = Net()
     with pytest.raises(ValueError) as ex:
         net()
-    assert "size and scale both not none" in str(ex.value)
+    assert "'size' and 'scale' both not none" in str(ex.value)