mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/ops/operations/inner_ops.py

@@ -16,19 +16,19 @@
 """inner_ops"""
 
 import numbers
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+import numpy as np
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
-from mindspore.common.dtype import tensor, dtype_to_pytype
+from mindspore.common.dtype import tensor
 from mindspore.ops.primitive import prim_attr_register, PrimitiveWithInfer, Primitive
 from mindspore.ops import signature as sig
 
 
-class ScalarCast(PrimitiveWithInfer):
+class ScalarCast(Primitive):
     """
     Casts the input scalar to another type.
 
-    Refer to :func:`mindspore.ops.scalar_cast` for more detail.
+    Refer to :func:`mindspore.ops.scalar_cast` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -42,21 +42,16 @@ class ScalarCast(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self):
-        pass
-
-    def __infer__(self, x, t):
-        validator.check_equal_int(len(x['shape']), 0, 'x shape', self.name)
-        value, to = x['value'], t['value']
-        if value is not None:
-            validator.check_value_type("value", value, [numbers.Number, bool], self.name)
-            if isinstance(to, type(tensor)):
-                to = to.element_type()
-            np_type = dtype_to_pytype(to)
-            value = np_type(value)
-        out = {'shape': x['shape'],
-               'dtype': t['value'],
-               'value': value}
-        return out
+        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(tensor)):
+            dtype = dtype.element_type()
+        np_dtype = str(dtype)
+        value = np.cast[np_dtype.lower()](x)
+        value = value.item()
+        return value
 
 
 class Randperm(Primitive):
@@ -70,7 +65,8 @@ class Randperm(Primitive):
         dtype (mindspore.dtype): The type of output. Default: mindspore.int32.
 
     Inputs:
-        - **n** (Tensor[int32]) - The input tensor with shape: (1,) and the number must be in [0, `max_length`].
+        - **n** (Tensor) - The input tensor with shape :math:`(1,)` with and dtype int32 or int64.
+          `n` must be in range [0, `max_length`].
 
     Outputs:
         - **output** (Tensor) - The output Tensor with shape: (`max_length`,) and type: `dtype`.
@@ -80,6 +76,9 @@ class Randperm(Primitive):
         TypeError: If `n` is not a Tensor.
         TypeError: If `n` has non-Int elements.
         TypeError: If `n` has negative elements.
+        TypeError: If `dtype` is not supported.
+        ValueError: If `n` is out of range of `dtype`.
+        ValueError: If `n` is larger than `max_length`.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -99,15 +98,18 @@ class Randperm(Primitive):
         """Initialize Randperm"""
         validator.check_value_type("pad", pad, [int], self.name)
         validator.check_value_type("max_length", max_length, [int], self.name)
-        validator.check_int(max_length, 1, Rel.GE, "max_length", self.name)
+        validator.check_int(max_length, 1, validator.GE, "max_length", self.name)
+        valid_values = (mstype.int8, mstype.int16, mstype.int32, mstype.int64, mstype.uint8, mstype.uint16,
+                        mstype.uint32, mstype.uint64, mstype.float16, mstype.float32, mstype.float64)
+        validator.check_type_name("dtype", dtype, valid_values, self.name)
         self.dtype = dtype
         self.max_length = max_length
         self.init_prim_io_names(inputs=[], outputs=['output'])
 
 
-class NoRepeatNGram(PrimitiveWithInfer):
-    """
-    Updates log_probs with repeat n-grams.
+class NoRepeatNGram(Primitive):
+    r"""
+    Updates the probability of occurrence of words with its corresponding n-grams.
 
     During beam search, if consecutive `ngram_size` words exist in the generated word sequence,
     the consecutive `ngram_size` words will be avoided during subsequent prediction.
@@ -119,8 +121,9 @@ class NoRepeatNGram(PrimitiveWithInfer):
         ngram_size (int): Size of n-grams, must be greater than 0. Default: 1.
 
     Inputs:
-        - **state_seq** (Tensor) - A 3-D tensor with shape: (batch_size, beam_width, m).
-        - **log_probs** (Tensor) - A 3-D tensor with shape: (batch_size, beam_width, vocab_size).
+        - **state_seq** (Tensor) - n-gram word series, a 3-D tensor with shape: :math:`(batch\_size, beam\_width, m)`.
+        - **log_probs** (Tensor) - Probability of occurrence of n-gram word series, a 3-D
+          tensor with shape: :math:`(batch\_size, beam\_width, vocab\_size)`.
           The value of log_probs will be replaced with -FLOAT_MAX when n-grams repeated.
 
     Outputs:
@@ -138,7 +141,7 @@ class NoRepeatNGram(PrimitiveWithInfer):
         ValueError: If the beam_width of `state_seq` and `log_probs` are not equal.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> no_repeat_ngram = ops.NoRepeatNGram(ngram_size=3)
@@ -170,24 +173,10 @@ class NoRepeatNGram(PrimitiveWithInfer):
     def __init__(self, ngram_size=1):
         """NoRepeatNGram Randperm"""
         validator.check_value_type("ngram_size", ngram_size, [int], self.name)
-        validator.check_int(ngram_size, 1, Rel.GE, "ngram_size", self.name)
+        validator.check_int(ngram_size, 1, validator.GE, "ngram_size", self.name)
         self.ngram_size = ngram_size
         self.init_prim_io_names(inputs=['state_seq', 'log_probs'], outputs=['log_probs'])
 
-    def infer_shape(self, seq_shape, log_shape):
-        validator.check_int(len(seq_shape), 3, Rel.EQ, "rank of state_seq", self.name)
-        validator.check_int(len(log_shape), 3, Rel.EQ, "rank of log_probs", self.name)
-        validator.check("state_seq shape[0]", seq_shape[0], "log_probs shape[0]", log_shape[0], Rel.EQ, self.name)
-        validator.check("state_seq shape[1]", seq_shape[1], "log_probs shape[1]", log_shape[1], Rel.EQ, self.name)
-        validator.check("ngram_size", self.ngram_size, "state_seq shape[2] + 1", seq_shape[2] + 1, Rel.LE, self.name)
-        return log_shape
-
-    def infer_dtype(self, seq_type, log_type):
-        validator.check_type_name("seq_type", seq_type, mstype.int32, self.name)
-        valid_values = (mstype.float16, mstype.float32, mstype.float64)
-        validator.check_type_name("log_type", log_type, valid_values, self.name)
-        return log_type
-
 
 class LambApplyOptimizerAssign(PrimitiveWithInfer):
     r"""
@@ -248,9 +237,9 @@ class LambApplyOptimizerAssign(PrimitiveWithInfer):
 
     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("var_shape", var_shape, "m_shape", m_shape, Rel.EQ, self.name)
-        validator.check("var_shape", var_shape, "v_shape", v_shape, Rel.EQ, self.name)
-        validator.check("var_shape", var_shape, "grad_shape", grad_shape, Rel.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,
@@ -310,7 +299,7 @@ class LambApplyWeightAssign(PrimitiveWithInfer):
         self.add_prim_attr('side_effect_mem', True)
 
     def infer_shape(self, w_norm_shape, g_norm_shape, lr_shape, update_shape, var_shape):
-        validator.check("var_shape", var_shape, "update_shape", update_shape, Rel.EQ, self.name)
+        validator.check("var_shape", var_shape, "update_shape", update_shape, validator.EQ, self.name)
         return var_shape
 
     def infer_dtype(self, w_norm_dtype, g_norm_dtype, lr_dtype, update_dtype, var_dtype):
@@ -478,9 +467,9 @@ class FusedCastAdamWeightDecay(PrimitiveWithInfer):
 
     def infer_shape(self, var_shape, m_shape, v_shape, lr_shape, beta1_shape, beta2_shape,
                     epsilon_shape, decay_shape, grad_shape, global_norm):
-        validator.check("var_shape", var_shape, "m_shape", m_shape, Rel.EQ, self.name)
-        validator.check("var_shape", var_shape, "v_shape", v_shape, Rel.EQ, self.name)
-        validator.check("var_shape", var_shape, "grad_shape", grad_shape, Rel.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 var_shape, m_shape, v_shape
 
     def infer_dtype(self, var_dtype, m_dtype, v_dtype, lr_dtype, beta1_dtype, beta2_dtype,
@@ -505,7 +494,7 @@ class FusedAdaFactor(PrimitiveWithInfer):
     Cost <https://arxiv.org/abs/1804.04235>`_.
 
     .. 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.
 
     Adafactor for weight vector are as follows,
 
@@ -616,7 +605,7 @@ class FusedAdaFactor(PrimitiveWithInfer):
     def infer_shape(self, epsilon_shape, clip_threshold_shape, beta1_shape, beta2t_shape, weight_decay_shape,
                     learning_rate_shape, grad_shape, param_shape, exp_avg_shape, exp_avg_sq_row_shape,
                     exp_avg_sq_col_shape, exp_avg_sq_shape):
-        validator.check("grad_shape", grad_shape, "param_shape", param_shape, Rel.EQ, self.name)
+        validator.check("grad_shape", grad_shape, "param_shape", param_shape, validator.EQ, self.name)
         return param_shape
 
     def infer_dtype(self, epsilon_type, clip_threshold_type, beta1_type, beta2t_type, weight_decay_type,
@@ -638,7 +627,7 @@ class FusedAdaFactorWithGlobalNorm(FusedAdaFactor):
     def infer_shape(self, epsilon_shape, clip_threshold_shape, beta1_shape, beta2t_shape, weight_decay_shape,
                     learning_rate_shape, grad_shape, param_shape, exp_avg_shape, exp_avg_sq_row_shape,
                     exp_avg_sq_col_shape, exp_avg_sq_shape, global_norm_shape):
-        validator.check("grad_shape", grad_shape, "param_shape", param_shape, Rel.EQ, self.name)
+        validator.check("grad_shape", grad_shape, "param_shape", param_shape, validator.EQ, self.name)
         return param_shape
 
     def infer_dtype(self, epsilon_type, clip_threshold_type, beta1_type, beta2t_type, weight_decay_type,

mindspore/ops/operations/linalg_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-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.
@@ -15,36 +15,41 @@
 
 """Operators for linalg."""
 
-from ..._checkparam import Validator
-from ..primitive import Primitive, prim_attr_register
+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"""
-    Geqrf is a low-level function for computing QR decompositions. This function returns two tensors
-    (y, tau).
+    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.
 
-    Computes a QR decomposition of `x`. Both `Q` and `R` matrices are stored in the same output tensor `y`.
-    The elements of `R` are stored on and above the diagonal.
-    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 two-dimensional matrix,
-          with dtype of float32, float64.
+        - **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`.
+        - **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 neither float32, float64.
-        ValueError: If `x` dimension is not equal to 2
+        TypeError: If the dtype of `x` is neither float32, float64, complex64, complex128.
+        ValueError: If `x` dimension is less than 2
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_x = Tensor(np.array([[-2.0, -1.0], [1.0, 2.0]]).astype(np.float32))
@@ -65,32 +70,30 @@ class Geqrf(Primitive):
 
 class Svd(Primitive):
     """
-    Refer to :func:`mindspore.ops.svd` for more detail.
+    Computes the singular value decompositions of one or more matrices.
+
+    Refer to :func:`mindspore.ops.svd` for more details.
 
     Args:
         full_matrices (bool, optional): If true, compute full-sized :math:`U` and :math:`V`. If false, compute
-                                        only the leading P singular vectors. P is the minimum of M and N.
-                                        M, N is the row, col of the input matrix. Default: False.
+                                        only the leading P singular vectors, with P is the minimum of M and N.
+                                        Default: False.
         compute_uv (bool, optional): If true, compute the left and right singular vectors.
                                      If false, compute only the singular values. Default: True.
 
     Inputs:
-        - **a**  (Tensor): Tensor of the matrices to be decomposed. The shape should be :math:`(*, M, N)`.
+        - **input** (Tensor) - Tensor of the matrices to be decomposed. The shape should be :math:`(*, M, N)`,
+          the supported dtype are float32 and float64.
 
     Outputs:
         - **s**  (Tensor) - Singular values. The shape is :math:`(*, P)`.
-        - **u**  (Tensor) - Left singular vectors. If compute_uv is False, u will be an empty tensor.
-          The shape is :math:`(*, M, P)`. If full_matrices is True, the shape will be :math:`(*, M, M)`.
-        - **v**  (Tensor) - Right singular vectors. If compute_uv is False, v will be an empty tensor.
-          The shape is :math:`(*, N, P)`. If full_matrices is True, the shape will be :math:`(*, N, N)`.
-
-    Raises:
-        TypeError: If full_matrices or compute_uv is not the type of bool.
-        TypeError: If the rank of input less than 2.
-        TypeError: If the type of input is not one of the following dtype: mstype.float32, mstype.float64.
+        - **u**  (Tensor) - Left singular vectors. If `compute_uv` is False, u will be zero value.
+          The shape is :math:`(*, M, P)`. If `full_matrices` is True, the shape will be :math:`(*, M, M)`.
+        - **v**  (Tensor) - Right singular vectors. If `compute_uv` is False, v will be zero value.
+          The shape is :math:`(*, N, P)`. If `full_matrices` is True, the shape will be :math:`(*, N, N)`.
 
     Supported Platforms:
-        ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np