mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/ops/operations/other_ops.py

@@ -17,7 +17,7 @@
 import functools
 from mindspore import log as logger
 from mindspore.ops import signature as sig
-from mindspore._checkparam import Validator as validator, Rel
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.ops.primitive import Primitive, PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register
 from mindspore.ops.operations._pyfunc_registry import add_pyfunc
@@ -27,7 +27,7 @@ class Assign(Primitive):
     """
     Assigns `Parameter` with a value.
 
-    Refer to :func:`mindspore.ops.assign` for more detail.
+    Refer to :func:`mindspore.ops.assign` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -36,8 +36,8 @@ class Assign(Primitive):
         >>> value = Tensor([2.0], mindspore.float32)
         >>> variable = mindspore.Parameter(Tensor([1.0], mindspore.float32), name="variable")
         >>> assign = ops.Assign()
-        >>> output = assign(variable, value)
-        >>> print(output)
+        >>> x = assign(variable, value)
+        >>> print(variable.asnumpy())
         [2.]
     """
     __mindspore_signature__ = (
@@ -118,7 +118,7 @@ class BoundingBoxEncode(PrimitiveWithInfer):
         stds (tuple): The standard deviations of deltas calculation. Default: (1.0, 1.0, 1.0, 1.0).
 
     Inputs:
-        - **anchor_box** (Tensor) - Anchor boxes. The shape of anchor_box must be (n, 4).
+        - **anchor_box** (Tensor) - Anchor boxes. The shape of anchor_box must be :math:`(n, 4)`.
         - **groundtruth_box** (Tensor) - Ground truth boxes. Which has the same shape with anchor_box.
 
     Outputs:
@@ -153,82 +153,6 @@ class BoundingBoxEncode(PrimitiveWithInfer):
         validator.check_equal_int(len(means), 4, "means len", self.name)
         validator.check_equal_int(len(stds), 4, "stds len", self.name)
 
-    def infer_shape(self, anchor_box, groundtruth_box):
-        validator.check('anchor_box shape[0]', anchor_box[0], 'groundtruth_box shape[0]', groundtruth_box[0], Rel.EQ,
-                        self.name)
-        validator.check("anchor_box rank", len(anchor_box), "", 2, Rel.EQ, self.name)
-        validator.check("groundtruth_box rank", len(groundtruth_box), "", 2, Rel.EQ, self.name)
-        validator.check_equal_int(anchor_box[1], 4, 'anchor_box shape[1]', self.name)
-        validator.check_equal_int(groundtruth_box[1], 4, 'groundtruth_box shape[1]', self.name)
-        return anchor_box
-
-    def infer_dtype(self, anchor_box, groundtruth_box):
-        args = {"anchor_box": anchor_box, "groundtruth_box": groundtruth_box}
-        validator.check_tensors_dtypes_same_and_valid(args, mstype.number_type, self.name)
-        return anchor_box
-
-
-class BartlettWindow(Primitive):
-    r"""
-    Bartlett window function.
-
-    The input "window_length" is a tensor that datatype must be a integer, which controlling the returned window size.
-    In particular, If "window_length" = 1, the returned window contains a single value 1.
-
-    Attr "periodic" determines whether the returned window trims off the last duplicate value from the symmetric window
-    and is ready to be used as a periodic window with functions. Therefore, if attr "periodic" is true, the "N" in
-    formula is in fact "window_length" + 1.
-
-    .. math::
-
-        w[n] = 1 - \left| \frac{2n}{N-1} - 1 \right| = \begin{cases}
-        \frac{2n}{N - 1} & \text{if } 0 \leq n \leq \frac{N - 1}{2} \\
-        2 - \frac{2n}{N - 1} & \text{if } \frac{N - 1}{2} < n < N \\
-        \end{cases},
-
-        \text{where : N is the full window size.}
-
-    Args:
-        periodic(bool): If True, returns a window to be used as periodic function. If False, return a symmetric window.
-                        Default: True.
-        dtype(mindspore.dtype): The desired datatype of returned tensor. Only float16, float32 and float64 is allowed.
-                                Default: mstype.float32.
-
-    Inputs:
-        - **window_length** (Tensor) - The size of returned window, with data type int32, int64.
-          The input data should be an integer with a value of [0, 1000000].
-
-    Outputs:
-        A 1-D tensor of size "window_length" containing the window. Its datatype is set by the attr 'dtype'.
-
-    Raises:
-        TypeError: If "window_length" is not a Tensor.
-        TypeError: If the type of "window_length" is not one of: int32, int64.
-        TypeError: If "periodic" is not a bool.
-        TypeError: If "dtype" is not one of: float16, float32, float64.
-        ValueError: If the value range of "window_length" is not [0,1000000].
-        ValueError: If the dimension of "window_length" is not 0.
-
-    Supported Platforms:
-        ``GPU``
-
-    Examples:
-        >>> window_length = Tensor(5, mstype.int32)
-        >>> bartlett_window = ops.BartlettWindow(periodic=True, dtype=mstype.float32)
-        >>> output = bartlett_window(window_length)
-        >>> print(output)
-        [0.  0.4 0.8 0.8 0.4]
-    """
-
-    @prim_attr_register
-    def __init__(self, periodic=True, dtype=mstype.float32):
-        """Initialize BartlettWindow"""
-        self.add_prim_attr("max_length", 1000000)
-        validator.check_value_type("periodic", periodic, [bool], self.name)
-        validator.check_value_type("dtype", dtype, [mstype.Type], self.name)
-        valid_values = (mstype.float16, mstype.float32, mstype.float64)
-        validator.check_type_name("dtype", dtype, valid_values, self.name)
-
 
 class BoundingBoxDecode(Primitive):
     """
@@ -238,13 +162,13 @@ class BoundingBoxDecode(Primitive):
     which is used to mark the target in the subsequent images, etc.
 
     Args:
+        max_shape (tuple): The max size limit for decoding box calculation.
         means (tuple): The means of deltas calculation. Default: (0.0, 0.0, 0.0, 0.0).
         stds (tuple): The standard deviations of deltas calculation. Default: (1.0, 1.0, 1.0, 1.0).
-        max_shape (tuple): The max size limit for decoding box calculation.
         wh_ratio_clip (float): The limit of width and height ratio for decoding box calculation. Default: 0.016.
 
     Inputs:
-        - **anchor_box** (Tensor) - Anchor boxes. The shape of `anchor_box` must be (n, 4).
+        - **anchor_box** (Tensor) - Anchor boxes. The shape of `anchor_box` must be :math:`(n, 4)`.
         - **deltas** (Tensor) - Delta of boxes. Which has the same shape with `anchor_box`.
 
     Outputs:
@@ -289,44 +213,53 @@ class BoundingBoxDecode(Primitive):
 
 class SampleDistortedBoundingBoxV2(Primitive):
     r"""
-    Generate a single randomly distorted bounding box for an image.
+    Creates a single bounding box that is randomly distorted for an image.
+
+    It is often used for object localization and image recognition tasks.
+    In such tasks, bounding box annotations are supplied in addition to ground-truth
+    labels, and data augmentation techniques are often used to randomly distort an image
+    while preserving its content.
 
-    Bounding box annotations are often supplied in addition to ground-truth labels in image recognition or object
-    localization tasks. A common technique for training such a system is to randomly distort an image while preserving
-    its content, i.e. data augmentation. This Op outputs a randomly distorted localization of an object, i.e. bounding
-    box, given an `image_size`, `bounding_boxes` and a series of constraints. The output is returned as 3 tensors:
-    `begin`, `size` and `bboxes`. The first 2 tensors can be fed directly into mindspore.ops.Slice to crop the image.
+    This function takes the `image_size`, `bounding_boxes`, and
+    a series of constraints as input, and outputs a randomly distorted localization of an
+    object (i.e., bounding box) based on these inputs.
+
+    The output is returned as 3 tensors:
+
+    The output is returned as 3 tensors:
+    `begin`, `size` and `bboxes`. The first 2 tensors can be fed directly
+    into :class:`mindspore.ops.Slice` to crop the image.
     The latter is the generated distorted bounding box.
 
     Args:
-    seed (int): If either seed or seed2 are set to non-zero, the random number generator is seeded by the given seed.
-                Otherwise, it is seeded by a random seed. Default: 0.
-    seed2 (int): A second seed to avoid seed collision. Default: 0.
-    aspect_ratio_range (Union[list(float), tuple(float)]): The cropped area of the image must have an aspect ratio =
-                                                           width / height within this range. The value of this
-                                                           attribute should be positive. Default: (0.75, 1.33).
-    area_range (Union[list(float), tuple(float)]): The cropped area of the image must contain a fraction of the
-                                                   supplied image within this range. The value of this attribute should
-                                                   be in range (0.0, 1.0]. Default: (0.05, 1.0).
-    max_attempts (int): Number of attempts at generating a cropped region of the image of the specified constraints.
-                        After max_attempts failures, return the entire image. The value of this attribute should be
-                        positive. Default: 100.
-    use_image_if_no_bounding_boxes (bool): Controls behavior if no bounding boxes supplied. If no bounding boxes
-                                           supplied (`bounding_boxes` in shape [0, N, 4] or [batch, 0, 4]), and this
-                                           attribute is set True, then assume an implicit bounding box covering the
-                                           whole input, else if this attribute is set False, then raise an error.
-                                           Default: False.
+        seed (int, optional): Random number seed. If either `seed` or `seed2` is set to a non-zero value,
+            the seed is to the given value. Otherwise, a random seed is uesed. Default: 0.
+        seed2 (int, optional): The second seed to avoid seed collision. Default: 0.
+        aspect_ratio_range (Union[list(float), tuple(float)], optional): Specifying the valild range of aspect
+            ratio of cropped area. Aspect ratio of area = area_width / area_height. The value of this
+            attribute should be positive. Default: (0.75, 1.33).
+        area_range (Union[list(float), tuple(float)], optional): The cropped area of the image must contain a
+            fraction of the supplied image within this range. The value of this attribute should
+            be in range (0.0, 1.0]. Default: (0.05, 1.0).
+        max_attempts (int, optional): A poditive integer specifies the number of attempts that will be made to
+            generate a cropped region of the image based on the given constraints. If the maximum number of
+            attempts is exceeded without success, the function will return the entire original image.
+            Default: 100.
+        use_image_if_no_bounding_boxes (bool, optional): Controls behavior if no bounding boxes supplied.
+            If no bounding boxes supplied (`bounding_boxes` in shape :math:`(0, N, 4)` or :math:`(batch, 0, 4)`), and
+            this attribute is set True, then assume an implicit bounding box covering the
+            whole input, else if this attribute is set False, then raise an error. Default: False.
 
     Inputs:
-        - **image_size** (Tensor) - 1-D, containing [height, width, channels]. The value of this input tensor should be
-          positive.
-        - **bounding_boxes** (Tensor) - 3-D with shape [batch, N, 4] describing the N bounding boxes associated with
-          the image. The value of this input tensor should be in range [0.0, 1.0]. The
-          data type is float32.
-        - **min_object_covered** (Tensor) - The cropped area of the image must contain at least this fraction of any
-          bounding box supplied. The value of this parameter should be in range
-          [0.0, 1.0]. In the case of 0, the cropped area does not need to overlap any
-          of the bounding boxes supplied. The data type is float32.
+        - **image_size** (Tensor) - 1-D Tensor, containing [height, width, channels]. The value of this input
+          tensor should be positive.
+        - **bounding_boxes** (Tensor) - 3-D Tensor with shape :math:`(batch, N, 4)` describing the N
+          bounding boxes associated with the image. The value of this input tensor should be in range [0.0, 1.0].
+          The data type is float32.
+        - **min_object_covered** (Tensor) - The least fraction of bounding box the croped area need to cover.
+          This parameter's value should be between 0.0 and 1.0, inclusive. If the value is 0,
+          the cropped area does not need to overlap with any of the supplied bounding boxes.
+          The data type is float32.
 
     Outputs:
         - **begin** (Tensor) - A 1-D Tensor, containing [offset_height, offset_width, 0]. The data type is same as
@@ -334,24 +267,21 @@ class SampleDistortedBoundingBoxV2(Primitive):
         - **size** (Tensor) - A 1-D Tensor, containing [target_height, target_width, -1]. The data type is same as
           `image_size`. When the data type of `image_size` is uint8, the last value of `size`,
           which is originally -1, will be forced to 255.
-        - **bboxes** (Tensor) - A 3-D Tensor with shape [1, 1, 4], containing the distorted bounding box. The data type
-          is float32.
+        - **bboxes** (Tensor) - A 3-D Tensor with shape :math:`(1, 1, 4)`, containing
+          the distorted bounding box. The data type is float32.
 
     Raises:
         TypeError: If `image_size` is not a Tensor.
         TypeError: If `bounding_boxes` is not a Tensor.
         TypeError: If `min_object_covered` is not a Tensor.
-        TypeError: If `seed` is not an int.
-        TypeError: If `seed2` is not an int.
+        TypeError: If `seed` or `seed2` is not an int.
         TypeError: If `aspect_ratio_range` is not a list or a tuple with type float.
         TypeError: If `area_range` is not a list or a tuple with type float.
-        TypeError: If `max_attempts` is not an int.
         TypeError: If `use_image_if_no_bounding_boxes` is not a bool.
         ValueError: If the dimension of `image_size` is not 1.
         ValueError: If the elements of `image_size` is not 3.
         ValueError: If the dimension of `bounding_boxes` is not 3.
         ValueError: If the elements of each bounding box in `bounding_boxes` is not 4.
-        ValueError: If the dimension of `min_object_covered` is not 1.
         ValueError: If the elements of `min_object_covered` is not 1.
         ValueError: If the elements of `aspect_ratio_range` list or tuple is not 2.
         ValueError: If the values of `aspect_ratio_range` is not positive.
@@ -359,11 +289,11 @@ class SampleDistortedBoundingBoxV2(Primitive):
         ValueError: If the elements of `area_range` list or tuple is not 2.
         ValueError: If the values of `area_range` is out of range (0.0, 1.0].
         ValueError: If the second value of `area_range` is less than or equal to the first one.
-        ValueError: If the value of `max_attempts` is not positive.
+        ValueError: If the value of `max_attempts` is not positive int.
         ValueError: If `use_image_if_no_bounding_boxes` is False and no bounding boxes supplied.
         RuntimeError: If the values of `image_size` is not positive.
         RuntimeError: If the values of `bounding_boxes` is out of range [0.0, 1.0].
-        RuntimeError: If the `bounding_boxes` cannot make up a bounding boxes.
+        RuntimeError: If the `bounding_boxes` cannot make up bounding box.
         RuntimeError: If the value of `min_object_covered` is out of range [0.0, 1.0].
 
     Supported Platforms:
@@ -409,19 +339,17 @@ class CheckValid(Primitive):
     """
     Checks bounding box.
 
-    Checks whether the bounding box cross data and data border are valid.
-
-    .. warning::
-        specifying the valid boundary (heights x ratio, weights x ratio).
+    Checks whether the bounding boxes specified by `bboxes` is valid.
+    Returns True if the box is within borders specified by `img_metas`, False if not.
 
     Inputs:
-        - **bboxes** (Tensor) - Bounding boxes tensor with shape (N, 4). "N" indicates the number of
+        - **bboxes** (Tensor) - Bounding boxes tensor with shape :math:`(N, 4)`. :math:`N` indicates the number of
           bounding boxes, the value "4" indicates "x0", "x1", "y0", and "y1". Data type must be float16 or float32.
-        - **img_metas** (Tensor) - Raw image size information with the format of (height, width, ratio), specifying
-          the valid boundary(height * ratio, width * ratio). Data type must be float16 or float32.
+        - **img_metas** (Tensor) - Raw image size information with the format of :math:`(height, width, ratio)`,
+          specifying the valid boundary :math:`(height * ratio, width * ratio)`. Data type must be float16 or float32.
 
     Outputs:
-        Tensor, with shape of (N,) and dtype of bool, specifying whether the bounding boxes is in the image.
+        Tensor, with shape of :math:`(N,)` and dtype of bool, specifying whether the bounding boxes is in the image.
         "True" indicates valid, while "False" indicates invalid.
 
     Raises:
@@ -465,7 +393,7 @@ class IOU(Primitive):
     Computes the intersection over union (IOU) or the intersection over foreground (IOF) based on the ground-truth and
     predicted regions.
 
-    Refer to :func:`mindspore.ops.iou` for more detail.
+    Refer to :func:`mindspore.ops.iou` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -503,10 +431,10 @@ class Partial(Primitive):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> import mindspore.ops as ops
         >>> def show_input(x, y, z):
         ...     return x, y, z
-        >>> partial = P.Partial()
+        >>> partial = ops.Partial()
         >>> partial_show_input = partial(show_input, Tensor(1))
         >>> output1 = partial_show_input(Tensor(2), Tensor(3))
         >>> print(output1)
@@ -613,98 +541,42 @@ class UpdateState(Primitive):
     def __init__(self):
         pass
 
-    def __call__(self, state, expr):
-        return state
+    def __call__(self, *args):
+        return args[0]
 
 
-class CheckBprop(PrimitiveWithInfer):
+class StopGradient(Primitive):
     """
-    Checks whether the data type and the shape of corresponding elements from tuples x and y are the same.
+    StopGradient is used for eliminating the effect of a value on the gradient,
+    such as truncating the gradient propagation from an output of a function.
 
-    Args:
-        prim_to_check (str): The name of the primitive being checked. Default: ''.
-
-    Inputs:
-        - **input_x** (tuple[Tensor]) - The `input_x` contains the outputs of bprop to be checked.
-        - **input_y** (tuple[Tensor]) - The `input_y` contains the inputs of bprop to check against.
-
-    Outputs:
-        Tuple[Tensor], the `input_x`,
-        if data type and shape of corresponding elements from `input_x` and `input_y` are the same.
-
-    Raises:
-        TypeError: If `input_x` or `input_y` is not a Tensor.
+    Refer to :func:`mindspore.ops.stop_gradient` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> class Net(nn.Cell):
-        ...     def __init__(self):
-        ...         super(Net, self).__init__()
-        ...         self.op = ops.CheckBprop()
-        ...     def construct(self, x, y):
-        ...         return self.op(x, y)
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor
+        >>> from mindspore import dtype as mstype
+        >>> def net(x, y):
+        ...     out1 = ops.MatMul()(x, y)
+        ...     out2 = ops.MatMul()(x, y)
+        ...     out2 = ops.StopGradient()(out2)
+        ...     return out1, out2
         ...
-        >>> net = Net()
-        >>> input_x = (Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32),)
-        >>> input_y = (Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32),)
-        >>> output = net(input_x, input_y)
+        >>> x = Tensor([[0.5, 0.6, 0.4], [1.2, 1.3, 1.1]], dtype=mstype.float32)
+        >>> y = Tensor([[0.01, 0.3, 1.1], [0.1, 0.2, 1.3], [2.1, 1.2, 3.3]], dtype=mstype.float32)
+        >>> grad_fn = ops.grad(net)
+        >>> output = grad_fn(x, y)
         >>> print(output)
-        (Tensor(shape=[2, 2], dtype=Float32, value=
-        [[ 2.00000000e+00,  2.00000000e+00],
-         [ 2.00000000e+00,  2.00000000e+00]]),)
+        [[1.4100001 1.6       6.5999994]
+         [1.4100001 1.6       6.5999994]]
     """
 
     @prim_attr_register
-    def __init__(self, prim_to_check=""):
-        """Initialize CheckBprop"""
-        self.prim_to_check = prim_to_check
-
-    def infer_shape(self, xshapes, yshapes):
-        tips = f"user defined method 'bprop'"
-        validator.check_value_type('grads', xshapes, (tuple,), tips)
-        validator.check_value_type('params', yshapes, (tuple,), tips)
-        if not len(xshapes) == len(yshapes):
-            raise ValueError(f"For {tips} the number of return values(gradients) must be equal to "
-                             f"the number of input arguments except 'out' and 'dout', "
-                             f"which is:{len(yshapes)} but got {len(xshapes)}.")
-        checking_range = len(yshapes)
-        for i in range(checking_range):
-            xshape = xshapes[i]
-            yshape = yshapes[i]
-            if not xshape or not yshape:
-                continue
-            if xshape != yshape:
-                raise ValueError(f"For {tips}, the {i}th return value(gradient of the {i}th argument) "
-                                 f"should have the same shape as the {i}th argument, "
-                                 f"which is:{yshape}, but got: {xshape}.")
-        return xshapes
-
-    def infer_dtype(self, xdtypes, ydtypes):
-        tips = f"user defined method 'bprop'"
-        validator.check_value_type('grads', xdtypes, (tuple,), tips)
-        validator.check_value_type('params', ydtypes, (tuple,), tips)
-        if not len(xdtypes) == len(ydtypes):
-            raise ValueError(f"For {tips}, the number of return values(gradients) must be equal to "
-                             f"the number of input arguments except 'out' and 'dout', "
-                             f"which is:{len(ydtypes)} but got {len(xdtypes)}.")
-        checking_range = len(ydtypes)
-        for i in range(checking_range):
-            xdtype = xdtypes[i]
-            ydtype = ydtypes[i]
-            if isinstance(xdtype, mstype.anything_type) or isinstance(ydtype, mstype.anything_type):
-                continue
-            if isinstance(ydtype, mstype.function_type):
-                if not isinstance(xdtype, mstype.env_type_type):
-                    raise TypeError(f"For {tips}, the {i}th return value(gradient of the {i}th argument) type "
-                                    f"should be {mstype.env_type_type}, but got {xdtype}.")
-                continue
-            if xdtype != ydtype:
-                raise TypeError(f"For {tips}, the {i}th return value(gradient of the {i}th argument) "
-                                f"should have the same dtype as the {i}th argument, "
-                                f"which is:{ydtype}, but got: {xdtype}.")
-        return xdtypes
+    def __init__(self):
+        pass
 
 
 class ConfusionMatrix(PrimitiveWithInfer):
@@ -748,10 +620,10 @@ class ConfusionMatrix(PrimitiveWithInfer):
         validator.check_value_type("dtype", dtype, [str], self.name)
 
     def infer_shape(self, labels, predictions, weights=None):
-        validator.check('labels dimension', len(labels), '', 1, Rel.EQ, self.name)
-        validator.check('labels shape', labels, 'predictions shape', predictions, Rel.EQ, self.name)
+        validator.check('labels dimension', len(labels), '', 1, validator.EQ, self.name)
+        validator.check('labels shape', labels, 'predictions shape', predictions, validator.EQ, self.name)
         if weights is not None:
-            validator.check('labels shape', labels, 'weights shape', weights, Rel.EQ, self.name)
+            validator.check('labels shape', labels, 'weights shape', weights, validator.EQ, self.name)
         ret = (self.num_classes, self.num_classes)
         return ret
 
@@ -844,6 +716,39 @@ class identity(Primitive):
         return x
 
 
+class PyInterpret(Primitive):
+    r"""
+    Interpret Python expression.
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        super(PyInterpret, self).__init__(self.__class__.__name__)
+        self.add_prim_attr('side_effect_io', True)
+
+
+class PyExecute(PrimitiveWithInfer):
+    r"""
+    Execute Python expression.
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        super(PyExecute, self).__init__(self.__class__.__name__)
+        self.add_prim_attr('side_effect_io', True)
+        self.add_prim_attr("primitive_target", "CPU")
+
+    def infer_shape(self, *args):
+        logger.error("The function output are empty tuple. Add a placeholder instead. "
+                     "Do not use it as it could be any uninitialized data.")
+        return ((1,),)
+
+    def infer_dtype(self, *args):
+        logger.error("The function output are empty tuple. Add a placeholder instead. "
+                     "Do not use it as it could be any uninitialized data.")
+        return (mstype.int32,)
+
+
 class PyFunc(PrimitiveWithInfer):
     r"""
     Execute Python function.
@@ -854,7 +759,7 @@ class PyFunc(PrimitiveWithInfer):
     checkpoint and load to the network again, but will lose any Python function state.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         fn (function): Python function which inputs and outputs should be Python built-in scalar or numpy ndarray.
@@ -903,10 +808,11 @@ class PyFunc(PrimitiveWithInfer):
         self.add_prim_attr('out_shapes', out_shapes)
         validator.check_value_type("in_types", in_types, [list, tuple], self.name)
         validator.check_value_type("in_shapes", in_shapes, [list, tuple], self.name)
-        validator.check("in_types length", len(in_types), "in_shapes length", len(in_shapes), Rel.EQ, self.name)
+        validator.check("in_types length", len(in_types), "in_shapes length", len(in_shapes), validator.EQ, self.name)
         validator.check_value_type("out_types", out_types, [list, tuple], self.name)
         validator.check_value_type("out_shapes", out_shapes, [list, tuple], self.name)
-        validator.check("out_types length", len(out_types), "out_shapes length", len(out_shapes), Rel.EQ, self.name)
+        validator.check("out_types length", len(out_types), "out_shapes length",
+                        len(out_shapes), validator.EQ, self.name)
         self.add_prim_attr("side_effect_io", stateful)
         self.add_prim_attr("primitive_target", "CPU")
         fake_output = False
@@ -933,63 +839,3 @@ class PyFunc(PrimitiveWithInfer):
         logger.warning("The function output are empty tuple. Add a placeholder instead. "
                        "Do not use it as it could be any uninitialized data.")
         return (mstype.int32,)
-
-
-class BlackmanWindow(Primitive):
-    r"""
-    Blackman window function.
-
-    The input "window_length" is a tensor that datatype must be a integer, which
-    controlling the returned window size. In particular, If "window_length" =1,
-    the returned window contains a single value 1.
-    Attr "periodic" determines whether the returned window trims off the last duplicate value
-    from the symmetric window and is ready to be used as a periodic window with functions.
-    Therefore, if attr "periodic" is true, the "N" in formula is in fact "window_length" + 1.
-
-    .. math::
-
-        w[n] = 0.42 - 0.5 cos(\frac{2\pi n}{N - 1}) + 0.08 cos(\frac{4\pi n}{N - 1})
-
-        \text{where : N is the full window size.}
-
-    Args:
-        periodic (bool): If True, returns a window to be used as periodic function.
-            If False, return a symmetric window. Default: True.
-        dtype (mindspore.dtype): the desired data type of returned tensor. Only float16, float32 and float64 is allowed.
-            Default: mindspore.float32.
-
-    Inputs:
-        - **window_length** (Tensor) - the size of returned window, with data type int32, int64.
-          The input data should be an integer with a value of [0, 1000000].
-
-    Outputs:
-        A 1-D tensor of size "window_length" containing the window. Its datatype is set by the attr 'dtype'
-    Raises:
-        TypeError: If "window_length" is not a Tensor.
-        TypeError: If "periodic" is not a bool.
-        TypeError: If "dtype" is not one of: float16, float32, float64.
-        TypeError: If the type of "window_length" is not one of: int32, int64.
-        ValueError: If the value range of "window_length" is not [0,1000000].
-        ValueError: If the dimension of "window_length" is not 0.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> window_length = Tensor(10, mindspore.int32)
-        >>> blackman_window = ops.BlackmanWindow(periodic = True, dtype = mindspore.float32)
-        >>> output = blackman_window(window_length)
-        >>> print(output)
-        [-2.9802322e-08  4.0212840e-02  2.0077014e-01  5.0978714e-01
-          8.4922993e-01  1.0000000e+00  8.4922981e-01  5.0978690e-01
-          2.0077008e-01  4.0212870e-02]
-    """
-
-    @prim_attr_register
-    def __init__(self, periodic=True, dtype=mstype.float32):
-        """Initialize BlackmanWindow"""
-        self.add_prim_attr("max_length", 1000000)
-        validator.check_value_type("periodic", periodic, [bool], self.name)
-        validator.check_value_type("dtype", dtype, [mstype.Type], self.name)
-        valid_values = (mstype.float16, mstype.float32, mstype.float64)
-        validator.check_type_name("dtype", dtype, valid_values, self.name)