mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/operations/other_ops.py

@@ -21,6 +21,9 @@ 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
+from mindspore._c_expression import typing
+from mindspore.ops.operations.array_ops import Identity
+from mindspore.ops._primitive_cache import _get_cache_prim
 
 
 class Assign(Primitive):
@@ -29,10 +32,20 @@ class Assign(Primitive):
 
     Refer to :func:`mindspore.ops.assign` for more details.
 
+    Inputs:
+        - **variable** (Parameter) - The `Parameter`. :math:`(N,*)` where :math:`*` means,
+          any number of additional dimensions, its rank should be less than 8.
+        - **value** (Tensor) - The value to be assigned, has the same shape with `variable`.
+
+    Outputs:
+        Tensor, has the same data type and shape as original `variable`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> value = Tensor([2.0], mindspore.float32)
         >>> variable = mindspore.Parameter(Tensor([1.0], mindspore.float32), name="variable")
         >>> assign = ops.Assign()
@@ -72,6 +85,9 @@ class Load(PrimitiveWithCheck):
         """Initialize Load."""
         self.init_prim_io_names(inputs=['ref', 'u'], outputs=['output'])
 
+    def __call__(self, *args):
+        return _get_cache_prim(Identity)()(args[0])
+
     def check_dtype(self, variable):
         if variable != mstype.type_refkey:
             validator.check_tensors_dtypes_same_and_valid({"variable": variable}, mstype.number_type, self.name)
@@ -114,8 +130,8 @@ class BoundingBoxEncode(PrimitiveWithInfer):
     and this offset will be used as a variable for the loss.
 
     Args:
-        means (tuple): Means for encoding bounding boxes 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).
+        means (tuple): Means for encoding bounding boxes 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)`` .
 
     Inputs:
         - **anchor_box** (Tensor) - Anchor boxes. The shape of anchor_box must be :math:`(n, 4)`.
@@ -132,6 +148,8 @@ class BoundingBoxEncode(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> anchor_box = Tensor([[2, 2, 2, 3], [2, 2, 2, 3]], mindspore.float32)
         >>> groundtruth_box = Tensor([[1, 2, 1, 4], [1, 2, 1, 4]], mindspore.float32)
         >>> boundingbox_encode = ops.BoundingBoxEncode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0))
@@ -163,9 +181,9 @@ class BoundingBoxDecode(Primitive):
 
     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).
-        wh_ratio_clip (float): The limit of width and height ratio for decoding box calculation. Default: 0.016.
+        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)`` .
+        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 :math:`(n, 4)`.
@@ -183,6 +201,8 @@ class BoundingBoxDecode(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> anchor_box = Tensor([[4, 1, 2, 1], [2, 2, 2, 3]], mindspore.float32)
         >>> deltas = Tensor([[3, 1, 2, 2], [1, 2, 1, 4]], mindspore.float32)
         >>> boundingbox_decode = ops.BoundingBoxDecode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0),
@@ -233,22 +253,22 @@ class SampleDistortedBoundingBoxV2(Primitive):
 
     Args:
         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.
+            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).
+            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).
+            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.
+            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.
+            whole input, else if this attribute is set False, then raise an error. Default: ``False`` .
 
     Inputs:
         - **image_size** (Tensor) - 1-D Tensor, containing [height, width, channels]. The value of this input
@@ -344,7 +364,7 @@ class CheckValid(Primitive):
 
     Inputs:
         - **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.
+          bounding boxes, the value "4" indicates "x0", "y0", "x1", and "y1". 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.
 
@@ -395,10 +415,28 @@ class IOU(Primitive):
 
     Refer to :func:`mindspore.ops.iou` for more details.
 
+    Args:
+        mode (string): The mode is used to specify the calculation method,
+                       now supporting ``'iou'`` (intersection over union) or ``'iof'``
+                       (intersection over foreground) mode. Default: ``'iou'`` .
+
+    Inputs:
+        - **anchor_boxes** (Tensor) - Anchor boxes, tensor of shape :math:`(N, 4)`.
+          "N" indicates the number of anchor boxes,
+          and the value "4" refers to "x0", "y0", "x1", and "y1". Data type must be float16 or float32.
+        - **gt_boxes** (Tensor) - Ground truth boxes, tensor of shape :math:`(M, 4)`. "M" indicates the number of ground
+          truth boxes, and the value "4" refers to "x0", "y0", "x1", and "y1". Data type must be float16 or float32.
+
+    Outputs:
+        Tensor, the 'iou' values, tensor of shape :math:`(M, N)`, with the same data type as `anchor_boxes`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> iou = ops.IOU(mode='iou')
         >>> anchor_boxes = Tensor(np.random.randint(1.0, 5.0, [3, 4]), mindspore.float16)
         >>> gt_boxes = Tensor(np.random.randint(1.0, 5.0, [3, 4]), mindspore.float16)
@@ -552,6 +590,12 @@ class StopGradient(Primitive):
 
     Refer to :func:`mindspore.ops.stop_gradient` for more details.
 
+    Inputs:
+        - **value** (Any) - The value whose effect on the gradient to be eliminated.
+
+    Outputs:
+        The same as `value`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -585,7 +629,7 @@ class ConfusionMatrix(PrimitiveWithInfer):
 
     Args:
         num_classes (int): The num of classes.
-        dtype (str): Data type of confusion matrix. Default: 'int32'.
+        dtype (str): Data type of confusion matrix. Default: ``'int32'`` .
 
     Inputs:
         - **labels** (Tensor) - real labels, tensor of 1-D. the dtype must be non-negative Integer.
@@ -628,10 +672,10 @@ class ConfusionMatrix(PrimitiveWithInfer):
         return ret
 
     def infer_dtype(self, labels, predictions, weights=None):
-        validator.check_subclass('labels', labels, mstype.tensor, self.name)
-        validator.check_subclass('predictions', predictions, mstype.tensor, self.name)
+        validator.check_subclass('labels', labels, mstype.tensor_type, self.name)
+        validator.check_subclass('predictions', predictions, mstype.tensor_type, self.name)
         if weights is not None:
-            validator.check_subclass('weights', weights, mstype.tensor, self.name)
+            validator.check_subclass('weights', weights, mstype.tensor_type, self.name)
         args = {"labels": labels, "predictions": predictions}
         validator.check_tensors_dtypes_same_and_valid(args, (mstype.number_type), self.name)
         return labels
@@ -642,9 +686,9 @@ class Push(PrimitiveWithInfer):
     Pushes the inputs of the corresponding optimizer to parameter server.
 
     Args:
-        optim_type (string): The optimizer type. Default: 'ApplyMomentum'.
+        optim_type (string): The optimizer type. Default: ``'ApplyMomentum'`` .
         only_shape_indices (list): The indices of input of which only shape
-                                   will be pushed to parameter server. Default: None.
+                                   will be pushed to parameter server. Default: ``None`` .
 
     Inputs:
         - **optim_inputs** (tuple) - The inputs for this kind of optimizer.
@@ -693,29 +737,6 @@ class Pull(PrimitiveWithInfer):
         return mstype.float32
 
 
-class identity(Primitive):
-    """
-    Makes a identify primitive, used for pynative mode.
-
-    Inputs:
-        - **x** (Any) - identity input value.
-
-    Outputs:
-        The same as input.
-    """
-
-    # Side effect will propagated from the first argument to return value.
-    side_effect_propagate = 1
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize identity."""
-        self.add_prim_attr('side_effect_propagate', 1)
-
-    def __call__(self, x):
-        return x
-
-
 class PyInterpret(Primitive):
     r"""
     Interpret Python expression.
@@ -834,8 +855,9 @@ class PyFunc(PrimitiveWithInfer):
 
     def infer_dtype(self, *args):
         if self.out_shapes:
-            return tuple(self.out_types)
+            dtype_list = tuple([typing.TensorType(dtype) for dtype in self.out_types])
+            return dtype_list
 
         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,)
+        return (typing.TensorType(mstype.int32),)