mindspore 2.2.11__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/operations/image_ops.py

@@ -20,6 +20,7 @@ from mindspore import context
 from mindspore import _checkparam as validator
 from mindspore.ops.primitive import prim_attr_register, Primitive
 from mindspore.common import dtype as mstype
+from ..auto_generate import ResizeLinear1D, ResizeBilinearV2, ResizeBicubic
 
 
 class AdjustSaturation(Primitive):
@@ -388,7 +389,7 @@ class NonMaxSuppressionV3(Primitive):
           single score associated with each box (i.e., each row of the `boxes` Tensor).
           It is required that the number of scores in `scores` must be equal to the number of boxes in `boxes`.
           The supported data type is float32.
-        - **max_output_size** (Union[Tensor, Number.Int]) - A scalar integer Tensor representing the maximum
+        - **max_output_size** (Union[Tensor, Number.int]) - A scalar integer Tensor representing the maximum
           number of boxes to be selected by non max suppression. The supported data type is int32.
         - **iou_threshold** (Union[Tensor, Number.Float]) - A scalar float Tensor represents the threshold
           used for determining if the intersection over union (IOU) between boxes is too high.
@@ -459,7 +460,7 @@ class NonMaxSuppressionWithOverlaps(Primitive):
           single score associated with each box (i.e., each row of the `boxes` Tensor).
           It is required that the number of scores in `scores` must be equal to the number of boxes in `boxes`.
           The supported data type is float32.
-        - **max_output_size** (Union[Tensor, Number.Int]) - A scalar integer Tensor representing the maximum
+        - **max_output_size** (Union[Tensor, Number.int]) - A scalar integer Tensor representing the maximum
           number of boxes to be selected by non max suppression, and max_output_size must be equal to or greater
           than 0.
           Types allowed:int32.
@@ -660,223 +661,6 @@ class RGBToHSV(Primitive):
         self.init_prim_io_names(inputs=['images'], outputs=['y'])
 
 
-class ResizeLinear1D(Primitive):
-    r"""
-    Using the linear interpolate method resize the input tensor 'x'.
-
-    For general resize, refer to :func:`mindspore.ops.interpolate` for more details.
-
-    .. warning::
-        - This is an experimental API that is subject to change.
-        - Currently, the Ascend platform only supports scenarios where the input `size` is Tuple or List.
-
-    Args:
-        coordinate_transformation_mode (str): Default is ``'align_corners'`` . Describes how to transform the
-            coordinate in the resized tensor to the coordinate in the original tensor. Other optional: 'half_pixel'.
-
-    Inputs:
-        - **x** (Tensor) - A 3-D tensor which to resize, with shape [batch, channel, width]. Must be one of the
-          following types: float16, float32, float64.
-        - **size** (Union[Tuple[int], List[int], Tensor[int]]): describes the new width of `x` .
-          A tuple or list or 1-D tensor with only one int element :math:`(new\_width)`.
-
-    Outputs:
-        A 3-D tensor which shape is [batch, channel, new_width] with the same type as `x`.
-
-    Raises:
-        TypeError: If dtype of `x` is not in the support list.
-        TypeError: If `size` is not in Union[Tuple[int], List[int], Tensor[int]].
-        TypeError: If `coordinate_transformation_mode` is not a string.
-        TypeError: If `coordinate_transformation_mode` is not in the support list.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> x = Tensor([[[1, 2, 3], [4, 5, 6]]], mindspore.float32)
-        >>> size = (6,)
-        >>> resize_linear_1d = ops.ResizeLinear1D(coordinate_transformation_mode="align_corners")
-        >>> output = resize_linear_1d(x, size)
-        >>> print(output)
-        [[[1. 1.4 1.8 2.2 2.6 3.]
-          [4. 4.4 4.8 5.2 5.6 6.]]]
-    """
-
-    @prim_attr_register
-    def __init__(self, coordinate_transformation_mode="align_corners"):
-        """Initialize ResizeLinear1D."""
-        self.init_prim_io_names(inputs=["x", "sizes"], outputs=["output"])
-        validator.check_value_type(
-            "coordinate_transformation_mode", coordinate_transformation_mode, [str], self.name)
-        validator.check_string(coordinate_transformation_mode, ["align_corners", "half_pixel"],
-                               "coordinate_transformation_mode", self.name)
-
-
-class ResizeBilinearV2(Primitive):
-    r"""
-    Resizes an image to a certain size using the bilinear interpolation.
-
-    The resizing only affects the lower two dimensions which represent the height and width.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        align_corners (bool, optional): If ``True`` , rescale input by :math:`(new\_height - 1) / (height - 1)`,
-                       which exactly aligns the 4 corners of images and resized images. If ``False`` ,
-                       rescale by :math:`new\_height / height`. Default: ``False`` .
-        half_pixel_centers (bool, optional): Whether half pixel center. If set to ``True`` , `align_corners` should be
-                           ``False`` . Default: ``False`` .
-
-    Inputs:
-        - **x** (Tensor): Image to be resized. Input images must be a 4-D tensor with shape
-          :math:`(batch, channels, height, width)`, with data type of float32 or float16.
-        - **size** (Union[tuple[int], list[int], Tensor]): The new size of the images.
-          A tuple or list or Tensor of 2 int elements :math:`(new\_height, new\_width)`.
-
-    Outputs:
-        Tensor, resized image. 4-D with shape :math:`(batch, channels, new\_height, new\_width)`,
-        with the same data type as input `x`.
-
-    Raises:
-        TypeError: If `align_corners` is not a bool.
-        TypeError: If `half_pixel_centers` is not a bool.
-        TypeError: If `align_corners` and `half_pixel_centers` are all ``True`` .
-        ValueError: If `half_pixel_centers` is ``True`` and device_target is CPU.
-        ValueError: If dim of `x` is not 4.
-        ValueError: If `size` is Tensor and its dim is not 1.
-        ValueError: If `size` contains other than 2 elements.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor([[[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]]], mindspore.float32)
-        >>> output = ops.ResizeBilinearV2()(x, (5, 5))
-        >>> print(output)
-        [[[[1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]]]]
-    """
-
-    @prim_attr_register
-    def __init__(self, align_corners=False, half_pixel_centers=False):
-        """Initialize ResizeBilinear."""
-        super().__init__(name="ResizeBilinearV2")
-        self.init_prim_io_names(inputs=['x', 'size'], outputs=['y'])
-        self.align_corners = validator.check_value_type("align_corners", align_corners, [bool], self.name)
-        self.half_pixel_centers = validator.check_value_type("half_pixel_centers",
-                                                             half_pixel_centers, [bool], self.name)
-        if half_pixel_centers and align_corners:
-            raise ValueError(f"If half_pixel_centers is True, align_corners must be False, but got {align_corners}")
-
-
-class ResizeBicubic(Primitive):
-    r"""
-    Resize images to size using bicubic interpolation.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        align_corners (bool, optional): If ``True`` , the centers of the 4 corner pixels of the input
-            and output tensors are aligned, preserving the values at the corner pixels. Default: ``False`` .
-        half_pixel_centers (bool, optional): Whether to use half-pixel center alignment. If set to ``True`` ,
-            `align_corners` should be ``False`` . Default: ``False`` .
-
-    Inputs:
-        - **images** (Tensor) - The input image must be a 4-D tensor of shape :math:`(batch, channels, height, width)`.
-          The format must be NCHW.
-          Types allowed: float16, float32, float64.
-        - **size** (Tensor) - A 1-D tensor with 2 elements: new_height, new_width.
-          Types allowed: int32.
-
-    Outputs:
-        A 4-D tensor with shape :math:`(batch, channels, new\_height, new\_width)` whose dtype is the same as `images` .
-
-    Raises:
-        TypeError: If the type of `images` is not allowed.
-        TypeError: If the type of `size` is not int32.
-        TypeError: If the type of `align_corners` is not bool.
-        TypeError: If the type of `half_pixel_centers` is not bool.
-        ValueError: If the dim of `images` is not 4.
-        ValueError: If the dim of `size` is not 1.
-        ValueError: If the number of elements in `size` is not 2.
-        ValueError: If any value of `size` is not positive.
-        ValueError: If the values of `align_corners` and `half_pixel_centers` are both ``True`` .
-
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> class NetResizeBicubic(nn.Cell):
-        ...     def __init__(self):
-        ...         super(NetResizeBicubic, self).__init__()
-        ...         align_corners = False
-        ...         half_pixel_centers = False
-        ...         self.resize = ops.ResizeBicubic(align_corners, half_pixel_centers)
-        ...
-        ...     def construct(self, images, size):
-        ...         return self.resize(images, size)
-        ...
-        >>> images = Tensor(np.array([1, 2, 3, 4]).reshape(1, 1, 2, 2).astype(np.float32))
-        >>> size = Tensor([1, 4], mindspore.int32)
-        >>> resizebicubic = NetResizeBicubic()
-        >>> output = resizebicubic(images, size)
-        >>> print(output)
-            [[[[1. 1.5 2. 2.09375]]]]
-    """
-
-    @prim_attr_register
-    def __init__(self, align_corners=False, half_pixel_centers=False):
-        """Initialize"""
-        validator.check_value_type('align_corners', align_corners, bool, self.name)
-        validator.check_value_type('half_pixel_centers', half_pixel_centers, bool, self.name)
-        self.init_prim_io_names(inputs=['images', 'size'], outputs=['y'])
-
-    def __infer__(self, images, size):
-        # get shape
-        images_shape = list(images['shape'])
-        size_shape = list(size['shape'])
-        # get value
-        if images['value'] is None:
-            raise ValueError(f"For '{self.name}', the 'images' cannot be None, but got {images['value']}.")
-        if size['value'] is None:
-            raise ValueError(f"For '{self.name}', the 'size' cannot be None, but got {size['value']}.")
-        size_value = size['value']
-        # get dtype
-        images_dtype = images['dtype']
-        size_dtype = size['dtype']
-        # check dytpe
-        validator.check_tensor_dtype_valid("images", images_dtype,
-                                           [mstype.int8, mstype.int16, mstype.int32, mstype.int64, mstype.float16,
-                                            mstype.float32, mstype.uint8, mstype.uint16, mstype.double], self.name)
-        validator.check_tensor_dtype_valid("size", size_dtype, [mstype.int32], self.name)
-        # check input shape rank
-        validator.check("images rank", len(images_shape), "expected", 4, validator.EQ, self.name)
-        validator.check("size rank", len(size_shape), "expected", 1, validator.EQ, self.name)
-        validator.check("size dim_0", size_shape[0], "expected", 2, validator.EQ, self.name)
-        # check size_value
-        validator.check("size[0]", size_value[0], "minimum", 0, validator.GT, self.name)
-        validator.check("size[1]", size_value[1], "minimum", 0, validator.GT, self.name)
-
-        batch_size = images_shape[0]
-        channel = images_shape[1]
-        height = size_value[0]
-        width = size_value[1]
-
-        out_shape = (batch_size, channel, height, width)
-        return {'shape': out_shape, 'dtype': mstype.float32, 'value': None}
-
-
 class ResizeArea(Primitive):
     r"""
     Resize images to a certain size using area interpolation.

mindspore/ops/operations/inner_ops.py

@@ -15,46 +15,12 @@
 
 """inner_ops"""
 
-import numbers
-import numpy as np
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.ops.primitive import prim_attr_register, PrimitiveWithInfer, Primitive
 from mindspore.ops import signature as sig
 
 
-class ScalarCast(Primitive):
-    """
-    Casts the input scalar to another type.
-
-    Refer to :func:`mindspore.ops.scalar_cast` for more details.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import ops
-        >>> scalar_cast = ops.ScalarCast()
-        >>> output = scalar_cast(255.0, mindspore.int32)
-        >>> print(output)
-        255
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        self.init_prim_io_names(inputs=['input_scalar', 'dtype'], outputs=['output_data'])
-
-    def __call__(self, x, dtype):
-        validator.check_value_type("x", x, [bool, numbers.Number], self.name)
-        if isinstance(dtype, type(mstype.tensor_type)):
-            dtype = dtype.element_type()
-        np_dtype = str(dtype)
-        value = np.cast[np_dtype.lower()](x)
-        value = value.item()
-        return value
-
-
 class Randperm(Primitive):
     """
     Generates n random samples from 0 to n-1 without repeating. If `max_length` > n,
@@ -238,14 +204,13 @@ class LambApplyOptimizerAssign(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self):
         """Initialize LambApplyOptimizerAssign"""
-        self.var_shape = "var_shape"
         self.add_prim_attr('side_effect_mem', True)
 
     def infer_shape(self, grad_shape, v_shape, m_shape, var_shape, beta1_shape, sub1_shape,
                     beta2_shape, sub2_shape, eps_shape, steps_shape, use_weight_shape, weight_decay_shape):
-        validator.check(self.var_shape, var_shape, "m_shape", m_shape, validator.EQ, self.name)
-        validator.check(self.var_shape, var_shape, "v_shape", v_shape, validator.EQ, self.name)
-        validator.check(self.var_shape, var_shape, "grad_shape", grad_shape, validator.EQ, self.name)
+        validator.check("var_shape", var_shape, "m_shape", m_shape, validator.EQ, self.name)
+        validator.check("var_shape", var_shape, "v_shape", v_shape, validator.EQ, self.name)
+        validator.check("var_shape", var_shape, "grad_shape", grad_shape, validator.EQ, self.name)
         return m_shape, v_shape, m_shape
 
     def infer_dtype(self, grad_dtype, v_dtype, m_dtype, var_dtype, beta1_dtype, sub1_dtype,
@@ -642,6 +607,55 @@ class FusedAdaFactorWithGlobalNorm(FusedAdaFactor):
         return param_type
 
 
+class GenerateEodMask(Primitive):
+    r"""
+    Given the input `inputs_ids`, if found eod_token_id, the output position and attention mask matrix will be reset.
+    This means the `position_id` will start counting from 0, and the corresponding mask matrix will be filled with 0.
+
+    Args:
+        eod_token_id (int) - In the NLP scenario, this value corresponds to the id of
+            the symbol of 'EodOfDocument' in the vocabulary.
+
+    Inputs:
+      - **inputs_ids** (Tensor) - token id, a 2-D Tensor with shape :math:`(batch\_size, seq\_length)`.
+
+    Outputs:
+      - **position_id** (Tensor) - position id matrix with same shape and type as original `inputs_ids`.
+      - **attention_mask** (Tensor) - attention mask matrix with type
+            float16 and shape :math:`(batch\_size, seq\_length)`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> op = ops.GenerateEodMask(eod_token_id=0)
+        >>> position, mask = op(Tensor([[1, 0, 3], [1, 0, 0]], dtype=mindspore.int32))
+        >>> print(position)
+        [[0 1 0] [0 0 1]]
+        >>> print(mask)
+        [[[ 1. 0. 0.]
+          [1. 1. 0.]
+          [0. 0. 1.]]
+         [[1. 0. 0.]
+          [0. 1. 0.]
+          [0. 1. 1.]]]
+
+    Raises:
+        - **TypeError** - If `eod_token_id` is not int.
+        - **TypeError** - If `inputs_ids` is not int.
+        - **ValueError** - If `inputs_ids` is not a 2-D Tensor.
+    """
+    @prim_attr_register
+    def __init__(self, n_pos, eod_token_id, n_step, n_error_mode='specific'):
+        """Initialize GenerateEodMask"""
+        validator.check_value_type("eod_token_id", eod_token_id, [int], self.name)
+        validator.check_value_type("n_pos", n_pos, [int], self.name)
+        validator.check_value_type("n_step", n_step, [list], self.name)
+        validator.check_value_type("n_error_mode", n_error_mode, [str], self.name)
+        self.init_prim_io_names(inputs=['inputs_ids'],
+                                outputs=['position_ids'])
+
+
 class ScaleGrad(PrimitiveWithInfer):
     """
     Scale the input grad according to the loss scale.

mindspore/ops/operations/linalg_ops.py

@@ -19,55 +19,7 @@ from __future__ import absolute_import
 from mindspore import _checkparam as Validator
 from mindspore.ops.primitive import Primitive
 from mindspore.ops.primitive import prim_attr_register
-
-
-class Geqrf(Primitive):
-    r"""
-    Decomposes a matrix into the product of an orthogonal matrix `Q` and an upper triangular matrix `R`.
-    The process is called QR decomposition: :math:`A = QR`.
-
-    Both `Q` and `R` matrices are stored in the same output tensor `y`.
-    The elements of `R` are stored on and above the diagonal, whereas elementary reflectors
-    (or Householder vectors) implicitly defining matrix `Q` are stored below the diagonal.
-
-    This function returns two tensors (`y`, `tau`).
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(*, m, n)`, input must be a matrix greater than or equal to 2D,
-          with dtype of float32, float64, complex64, complex128.
-
-    Outputs:
-        - **y** (Tensor) - Tensor of shape :math:`(*, m, n)`, has the same dtype as the `x`.
-        - **tau** (Tensor) - Tensor of shape :math:`(*, p)` and :math:`p = min(m, n)`, has the same dtype as the `x`.
-
-    Raises:
-        TypeError: If `x` is not a Tensor.
-        TypeError: If the dtype of `x` is not float32, float64, complex64 or complex128.
-        ValueError: If dimension of `x` is less than 2.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.array([[-2.0, -1.0], [1.0, 2.0]]).astype(np.float32))
-        >>> geqrf = ops.Geqrf()
-        >>> y, tau = geqrf(input_x)
-        >>> print(y)
-        [[ 2.236068   1.7888544]
-         [-0.236068   1.3416407]]
-        >>> print(tau)
-        [1.8944271 0.       ]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Geqrf"""
-        self.init_prim_io_names(inputs=['x'], outputs=['y', 'tau'])
+from ..auto_generate import Geqrf
 
 
 class Svd(Primitive):

mindspore/{rewrite/ast_transformers → ops/operations/manually_defined}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,6 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""Transformers for optimizing ast."""
-from .flatten_recursive_stmt import FlattenRecursiveStmt
-from .remove_return_out_of_if import RemoveReturnOutOfIf
+
+"""
+Manually-defined operators.
+"""
+
+from . import ops_def
+
+from .ops_def import *
+
+__all__ = []

mindspore/ops/operations/manually_defined/_inner.py

@@ -0,0 +1,61 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""
+Inner-defined operators.
+"""
+
+import numbers
+import numpy as np
+from mindspore.common import dtype as mstype
+from mindspore import _checkparam as validator
+from mindspore.common._decorator import deprecated
+from mindspore.ops.primitive import prim_attr_register, Primitive
+
+
+class ScalarCast(Primitive):
+    """
+    'ops.ScalarCast' is deprecated from version 2.3 and will be removed in a future version,
+    please use `int(x)` or `float(x)` instead.
+
+    Supported Platforms:
+        Deprecated
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> scalar_cast = ops.ScalarCast()
+        >>> output = scalar_cast(255.0, mindspore.int64)
+        >>> print(output)
+        255
+    """
+
+    @deprecated("2.3", "ops.ScalarCast", False)
+    @prim_attr_register
+    def __init__(self):
+        self.init_prim_io_names(inputs=['input_x', 'input_y'], outputs=['output_data'])
+
+    def __call__(self, input_x, input_y):
+        validator.check_value_type("x", input_x, [bool, numbers.Number], self.name)
+        if input_y not in (mstype.int64, mstype.float64, mstype.bool_):
+            raise ValueError(f"For 'ScalarCast', the supported type is in the list: "
+                             f"[mindspore.int64, mindspore.float64, mindspore.bool], but got {input_y}")
+        dtype = input_y
+        if isinstance(dtype, type(mstype.tensor_type)):
+            dtype = dtype.element_type()
+        np_dtype = str(dtype)
+        value = np.cast[np_dtype.lower()](input_x)
+        value = value.item()
+        return value