mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/operations/inner_ops.py

@@ -16,15 +16,15 @@
 """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.
 
@@ -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,7 @@ class Randperm(Primitive):
         dtype (mindspore.dtype): The type of output. Default: mindspore.int32.
 
     Inputs:
-        - **n** (Tensor) - The input tensor with shape (1,) with and dtype int32 or int64.
+        - **n** (Tensor) - The input tensor with shape :math:`(1,)` with and dtype int32 or int64.
           `n` must be in range [0, `max_length`].
 
     Outputs:
@@ -103,14 +98,17 @@ 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):
-    """
+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,
@@ -123,9 +121,9 @@ class NoRepeatNGram(PrimitiveWithInfer):
         ngram_size (int): Size of n-grams, must be greater than 0. Default: 1.
 
     Inputs:
-        - **state_seq** (Tensor) - n-gram word series, a 3-D tensor with shape: (batch_size, beam_width, m).
+        - **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: (batch_size, beam_width, vocab_size).
+          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:
@@ -175,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"""
@@ -253,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,
@@ -315,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):
@@ -483,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,
@@ -510,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,
 
@@ -621,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,
@@ -643,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.
@@ -16,21 +16,24 @@
 """Operators for linalg."""
 
 from __future__ import absolute_import
-from mindspore._checkparam import Validator
+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 matrix greater than or equal to 2D,
@@ -46,7 +49,7 @@ class Geqrf(Primitive):
         ValueError: If `x` dimension is less than 2
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_x = Tensor(np.array([[-2.0, -1.0], [1.0, 2.0]]).astype(np.float32))
@@ -71,12 +74,31 @@ class Svd(Primitive):
 
     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, 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:
+        - **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 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`` ``CPU``
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor, ops, set_context
+        >>> from mindspore import Tensor, set_context
+        >>> from mindspore import ops
         >>> set_context(device_target="CPU")
         >>> svd = ops.Svd(full_matrices=True, compute_uv=True)
         >>> a = Tensor(np.array([[1, 2], [-4, -5], [2, 1]]).astype(np.float32))