mindspore 2.2.11__cp37-none-any.whl → 2.2.14__cp37-none-any.whl

mindspore/mindrecord/tools/csv_to_mr.py

@@ -22,10 +22,6 @@ from mindspore import log as logger
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread
 
-try:
-    pd = import_module("pandas")
-except ModuleNotFoundError:
-    pd = None
 
 __all__ = ['CsvToMR']
 
@@ -55,8 +51,7 @@ class CsvToMR:
     """
 
     def __init__(self, source, destination, columns_list=None, partition_number=1):
-        if not pd:
-            raise Exception("Module pandas is not found, please use pip install it.")
+        self.pd = import_module("pandas")
         if isinstance(source, str):
             check_filename(source)
             self.source = source
@@ -135,8 +130,8 @@ class CsvToMR:
         if not os.path.exists(self.source):
             raise IOError("Csv file {} do not exist.".format(self.source))
 
-        pd.set_option('display.max_columns', None)
-        df = pd.read_csv(self.source)
+        self.pd.set_option('display.max_columns', None)
+        df = self.pd.read_csv(self.source)
 
         csv_schema = self._get_schema(df)
 

mindspore/mindrecord/tools/mnist_to_mr.py

@@ -25,10 +25,6 @@ from mindspore import log as logger
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread, SUCCESS, FAILED
 
-try:
-    cv_import = import_module("cv2")
-except ModuleNotFoundError:
-    cv_import = None
 
 __all__ = ['MnistToMR']
 
@@ -58,6 +54,8 @@ class MnistToMR:
     """
 
     def __init__(self, source, destination, partition_number=1):
+        self.cv_import = import_module("cv2")
+
         self.image_size = 28
         self.num_channels = 1
 
@@ -89,9 +87,6 @@ class MnistToMR:
 
     # pylint: disable=missing-docstring
     def run(self):
-        if not cv_import:
-            raise ModuleNotFoundError("opencv-python module not found, please use pip install it.")
-
         if self._transform_train() == FAILED:
             return FAILED
         if self._transform_test() == FAILED:
@@ -155,7 +150,7 @@ class MnistToMR:
         train_data = self._extract_images(self.train_data_filename_)
         train_labels = self._extract_labels(self.train_labels_filename_)
         for data, label in zip(train_data, train_labels):
-            _, img = cv_import.imencode(".jpeg", data)
+            _, img = self.cv_import.imencode(".jpeg", data)
             yield {"label": int(label), "data": img.tobytes()}
 
     def _mnist_test_iterator(self):
@@ -168,7 +163,7 @@ class MnistToMR:
         test_data = self._extract_images(self.test_data_filename_)
         test_labels = self._extract_labels(self.test_labels_filename_)
         for data, label in zip(test_data, test_labels):
-            _, img = cv_import.imencode(".jpeg", data)
+            _, img = self.cv_import.imencode(".jpeg", data)
             yield {"label": int(label), "data": img.tobytes()}
 
     def _transform_train(self):

mindspore/mindrecord/tools/tfrecord_to_mr.py

@@ -97,10 +97,7 @@ class TFRecordToMR:
     """
 
     def __init__(self, source, destination, feature_dict, bytes_fields=None):
-        try:
-            self.tf = import_module("tensorflow")  # just used to convert tfrecord to mindrecord
-        except ModuleNotFoundError:
-            raise Exception("Module tensorflow is not found, please use pip install it.")
+        self.tf = import_module("tensorflow")  # just used to convert tfrecord to mindrecord
 
         if self.tf.__version__ < SupportedTensorFlowVersion:
             raise Exception("Module tensorflow version must be greater or equal {}.".format(SupportedTensorFlowVersion))

mindspore/nn/layer/activation.py

@@ -782,7 +782,7 @@ class Tanhshrink(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
+        >>> import mindspore as ms
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
         >>> x = Tensor(np.array([1, 2, 3, 2, 1]), ms.float16)

mindspore/nn/layer/embedding.py

@@ -522,12 +522,12 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
           this interface. Type is Int32, Int64.
         - **input_values** (Tensor) - The shape of tensor is :math:`(batch\_size, seq\_length)`.
           Specifies the weights of elements of the input_indices. The lookout vector will multiply with
-          the input_values. Type is Float32.
+          the input_values. Type is float32.
         - **field_ids** (Tensor)  - The shape of tensor is :math:`(batch\_size, seq\_length)`.
           Specifies the field id of elements of the input_indices. Type is Int32.
 
     Outputs:
-        Tensor, the shape of tensor is :math:`(batch\_size, field\_size, embedding\_size)`. Type is Float32.
+        Tensor, the shape of tensor is :math:`(batch\_size, field\_size, embedding\_size)`. Type is float32.
 
     Raises:
         TypeError: If `vocab_size` or `embedding_size` or `field_size` is not an int.

mindspore/nn/loss/loss.py

@@ -1996,7 +1996,7 @@ class FocalLoss(LossBase):
         >>> import mindspore.nn as nn
         >>> logits = ms.Tensor([[0.8, 1.4], [0.5, 0.9], [1.2, 0.9]], ms.float32)
         >>> labels = ms.Tensor([[1], [1], [0]], ms.int32)
-        >>> focalloss = nn.FocalLoss(weight=Tensor([1, 2]), gamma=2.0, reduction='mean')
+        >>> focalloss = nn.FocalLoss(weight=ms.Tensor([1, 2]), gamma=2.0, reduction='mean')
         >>> output = focalloss(logits, labels)
         >>> print(output)
         0.12516622

mindspore/nn/optim/ada_grad.py

@@ -162,7 +162,7 @@ class Adagrad(Optimizer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
+        >>> from mindspore import train
         >>> import mindspore.nn as nn
         >>>
         >>> # Define the network structure of LeNet5. Refer to
@@ -185,7 +185,7 @@ class Adagrad(Optimizer):
         >>> # The final parameters order in which the optimizer will be followed is the value of 'order_params'.
         >>>
         >>> loss = nn.SoftmaxCrossEntropyWithLogits()
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = train.Model(net, loss_fn=loss, optimizer=optim)
     """
 
     @opt_init_args_register

mindspore/nn/optim/sgd.py

@@ -193,9 +193,9 @@ class SGD(Optimizer):
                             "or 'weight_decay' set in grouped 'params' must be float or int type.")
 
         if hasattr(self, "group_weight_decay") and self.group_weight_decay:
-            self.opt = tuple(P.SGD(dampening, wd, nesterov) for wd in self.group_weight_decay)
+            self.opt = tuple(P.SGD(dampening, 0.0, nesterov) for _ in self.group_weight_decay)
         else:
-            self.opt = tuple([P.SGD(dampening, float(weight_decay), nesterov)] * len(self._parameters))
+            self.opt = tuple([P.SGD(dampening, 0.0, nesterov)] * len(self._parameters))
 
         self.momentum = Parameter(Tensor(momentum, mstype.float32), name="momentum")
 
@@ -220,6 +220,7 @@ class SGD(Optimizer):
         params = self._parameters
         accum = self.accum
         stat = self.stat
+        gradients = self.decay_weight(gradients)
         gradients = self.flatten_gradients(gradients)
         gradients = self.gradients_centralization(gradients)
         gradients = self.scale_grad(gradients)

mindspore/numpy/math_ops.py

@@ -4285,7 +4285,7 @@ def argmin(a, axis=None):
 
     Examples:
         >>> import mindspore.numpy as np
-        >>> a = np.arange(10, 16).reshape(2, 3)
+        >>> a = np.arange(10, 16).reshape(2, 3).astype(np.float32)
         >>> print(np.argmin(a))
         0
         >>> print(np.argmin(a, axis=0))

mindspore/ops/__init__.py

@@ -34,6 +34,7 @@ from mindspore.ops.composite import *
 from mindspore.ops.operations import *
 from mindspore.ops.function import *
 from mindspore.ops.functional import *
+from mindspore.ops.silent_check import _silent_check
 
 __primitive__ = [
     "prim_attr_register", "Primitive", "PrimitiveWithInfer", "PrimitiveWithCheck", "signature"
@@ -48,3 +49,5 @@ __all__.extend(composite.__all__)
 __all__.extend(operations.__all__)
 __all__.extend(functional.__all__)
 __all__.extend(function.__all__)
+
+_silent_check()

mindspore/ops/_grad_experimental/grad_array_ops.py

@@ -36,8 +36,6 @@ from mindspore.ops.operations.array_ops import ScatterAddWithAxis
 from mindspore.ops.operations.array_ops import Expand
 from mindspore.ops.operations.array_ops import SegmentMean
 from mindspore.ops.operations.array_ops import AffineGrid
-from mindspore.ops.operations.array_ops import Im2Col
-from mindspore.ops.operations.array_ops import Col2Im
 from mindspore.ops.operations.array_ops import MaskedScatter
 from mindspore.ops.operations.array_ops import MaskedSelect
 from mindspore.ops.operations.array_ops import CountNonZero
@@ -360,35 +358,6 @@ def get_bprop_resize_nearest_neighbor_v2(self):
     return bprop
 
 
-@bprop_getters.register(Im2Col)
-def get_bprop_im2col(self):
-    """
-    Generate bprop for Im2Col
-
-    Im2Col, corresponding to torch's UnFold operator.
-    The Unfold operator has no `padding_mode` attribute,
-    and it's implementation corresponds to the mindspore
-    implementation with `padding_mode=CALCULATED` .
-    So, currently the bprop function of Im2Col only supports
-    the CALCULATED mode.
-    """
-    kernel_size = self.ksizes
-    dilation = self.dilations
-    stride = self.strides
-    padding = (self.pads[0], self.pads[-1])
-    col2im = Col2Im(kernel_size=kernel_size,
-                    dilation=dilation,
-                    stride=stride,
-                    padding=padding)
-
-    def bprop(x, out, dout):
-        x_shape = P.TensorShape()(x)[2:]
-        dx = col2im(dout, x_shape)
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(P.ExtractVolumePatches)
 def get_bprop_extract_volume_patches(self):
     """Generate bprop for ExtractVolumePatches"""

mindspore/ops/_grad_experimental/grad_comm_ops.py

@@ -92,7 +92,8 @@ def get_bprop_send(self):
     """Generate bprop for Send."""
     shape = self.get_attr_dict()["shape"]
     dtype = self.get_attr_dict()["dtype"]
-    send_grad = Receive(self.sr_tag, self.rank, shape, dtype, self.group_back)
+    tag = self.get_attr_dict()["sr_tag"]
+    send_grad = Receive(tag, self.rank, shape, dtype, self.group_back)
     virtual_input = Tensor(0.0, dtype)
 
     def bprop(x, out, dout):
@@ -105,7 +106,8 @@ def get_bprop_send(self):
 @bprop_getters.register(Receive)
 def get_bprop_receive(self):
     """Generate bprop for Receive."""
-    receive_grad = Send(self.tag, self.rank, self.group_back)
+    tag = self.get_attr_dict()["sr_tag"]
+    receive_grad = Send(tag, self.rank, self.group_back)
     depend = P.Depend()
     cast = P.Cast()
     out_tensor = Tensor(0.0, mstype.float16)

mindspore/ops/_grad_experimental/grad_inner_ops.py

@@ -36,6 +36,14 @@ def get_bprop_parallel_resize_bilinear(self):
     return bprop
 
 
+@bprop_getters.register(P.inner_ops.GenerateEodMask)
+def get_bprop_generate_eod_mask(self):
+
+    def bprop(x, out, dout):
+        return dout, dout
+    return bprop
+
+
 @bprop_getters.register(inner.PsROIPooling)
 def get_bprop_ps_roi_pooling(self):
     """Grad definition for `PsROIPooling` operation."""

mindspore/ops/_grad_experimental/grad_math_ops.py

@@ -18,11 +18,13 @@
 import numpy as np
 import mindspore.numpy as mnp
 from mindspore.common import dtype as mstype
+import mindspore.ops as ops
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 from mindspore import Tensor
 from mindspore.ops.operations.math_ops import Real, Imag, Complex, Angle
-from mindspore.ops.operations.math_ops import Polar
+from mindspore.ops.operations.math_ops import Polar, SilentCheck
+from mindspore.ops.operations._inner_ops import _MirrorSilentCheck
 from mindspore.ops.operations import _grad_ops as G
 from mindspore.ops.operations.math_ops import Lgamma
 from mindspore.ops.operations.math_ops import Digamma
@@ -763,6 +765,7 @@ def get_bprop_fft_with_size(self):
     to_tensor_op = P.ScalarToTensor()
     type_op = P.DType()
     concat_op = P.Concat()
+    concat_op_last = P.Concat(axis=-1)
     ones_op = P.Ones()
     zeros_op = P.Zeros()
     real_op = P.Real()
@@ -794,8 +797,7 @@ def get_bprop_fft_with_size(self):
                                  signal_sizes=offset_shape[-1:])
             irfft2d_ = FFTWithSize(signal_ndim=2, inverse=True, real=True, norm="backward", onesided=onesided,
                                    signal_sizes=offset_shape[-2:])
-            irfft3d_ = FFTWithSize(signal_ndim=3, inverse=True, real=True, norm="backward", onesided=onesided,
-                                   signal_sizes=offset_shape[-3:])
+            irfft3d_ = FFTWithSize(signal_ndim=3, inverse=True, real=False, norm="backward", onesided=onesided)
             if inverse is False:
                 if onesided is True:
                     terms = 0
@@ -811,6 +813,7 @@ def get_bprop_fft_with_size(self):
                         vec_mask = complex_op(1 - 2 * (mnp.arange(0, input_shape[-1], 1, input_type) % 2),
                                               zeros_op(input_shape[-1], input_type))
                         terms = real_op(dout_first) + is_even * real_op(dout_last * vec_mask)
+                        dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
                     elif signal_ndim == 2:
                         dx = irfft2d_(dout)
                         arange_inner = mnp.arange(0, input_shape[-2], 1, input_type)
@@ -852,26 +855,27 @@ def get_bprop_fft_with_size(self):
                                                         dout_shape, [input_shape[-1]])))
                         dout_last_term = dout_last_term * vec_mask
                         terms = real_op(dout_first_term) + is_even * real_op(dout_last_term)
+                        dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
                     elif signal_ndim == 3:
-                        dx = irfft3d_(dout) * real_op(offset_size)
-                    dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
+                        zeros_shape = offset_shape[:-1] + (offset_shape[-1] - dout_shape[-1],)
+                        zeros_values = zeros_op(zeros_shape, input_type)
+                        zeros_padding = complex_op(zeros_values, zeros_values)
+                        dout = concat_op_last((dout, zeros_padding))
+                        dx = real_op(irfft3d_(dout)) * real_op(offset_size)
                 else:
                     dx = irfft_fn(dout) * real_op(offset_size)
             else:
                 dx = rfft_fn(dout)
                 if onesided is True:
-                    if signal_ndim != 3:
-                        is_odd = dout_shape[-1] % 2
-                        last_shape = offset_shape[-1]
-                        mask = concat_op((ones_op(1, output_type), 2.0 * ones_op(
-                            (last_shape - 2 + is_odd,), output_type), ones_op((1 - is_odd,), output_type)))
-                        dx = dx * complex_op(mask, zeros_op(shape_op(mask), output_type))
-                        irfft_offset_size = to_tensor_op(
-                            _fft_with_size_back_norm(shape_op(dout), norm, inverse, signal_ndim),
-                            output_type)
-                        dx = dx * complex_op(irfft_offset_size, zeros_op(1, output_type))
-                    else:
-                        dx = dx * complex_op(offset_size, zeros_op(1, output_type))
+                    is_odd = dout_shape[-1] % 2
+                    last_shape = offset_shape[-1]
+                    mask = concat_op((ones_op(1, output_type), 2.0 * ones_op(
+                        (last_shape - 2 + is_odd,), output_type), ones_op((1 - is_odd,), output_type)))
+                    dx = dx * complex_op(mask, zeros_op(shape_op(mask), output_type))
+                    irfft_offset_size = to_tensor_op(
+                        _fft_with_size_back_norm(shape_op(dout), norm, inverse, signal_ndim),
+                        output_type)
+                    dx = dx * complex_op(irfft_offset_size, zeros_op(1, output_type))
                 else:
                     dx = dx * complex_op(offset_size, zeros_op(1, output_type))
         return (dx,)
@@ -1017,3 +1021,19 @@ def get_bprop_tensor_add(self):
         return binop_grad_common(x, y, dout, dout)
 
     return bprop
+
+
+@bprop_getters.register(_MirrorSilentCheck)
+def get_bprop_mirror_silent_check(self):
+    """Grad definition for '_MirrorSilentCheck' op"""
+    silent_check = SilentCheck(self.min_steps, self.thresh_l1, self.coeff_l1, self.thresh_l2, self.coeff_l2)
+    out_tensor = Tensor([0.0], mstype.float32)
+
+    def bporp(x, pre_val, min_val, max_val, n_step, loss_scale, out, dout):
+        if loss_scale is not None:
+            dout = dout / loss_scale
+        grad = ops.norm(dout)
+        dx, _, _, _, _ = silent_check(grad, dout, pre_val, min_val, max_val, n_step)
+        return (dx, out_tensor, out_tensor, out_tensor, out_tensor, out_tensor)
+
+    return bporp

mindspore/ops/_op_impl/aicpu/__init__.py

@@ -60,6 +60,7 @@ from .init_data_set_queue import _init_data_set_queue_aicpu
 from .embedding_lookup import _embedding_lookup_aicpu
 from .padding import _padding_aicpu
 from .gather import _gather_aicpu
+from .generate_eod_mask import _generate_eod_mask_aicpu
 from .gather_grad import _gather_grad_aicpu
 from .gather_d_grad_v2 import _gather_d_grad_v2_aicpu
 from .gather_d import _gather_d_aicpu

mindspore/ops/_op_impl/aicpu/generate_eod_mask.py

@@ -0,0 +1,38 @@
+# 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.
+# ============================================================================
+
+"""GenerateEodMask op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+generate_eod_mask_op_info = AiCPURegOp("GenerateEodMask") \
+    .fusion_type("OPAQUE") \
+    .attr("eod_token_id", "int") \
+    .attr("n_pos", "int") \
+    .attr("n_step", "listint") \
+    .attr("n_error_mode", "str") \
+    .input(0, "inputs_ids", "required") \
+    .output(0, "position_ids", "required") \
+    .dtype_format(DataType.U16_Default, DataType.U16_Default) \
+    .dtype_format(DataType.U32_Default, DataType.U32_Default) \
+    .dtype_format(DataType.U64_Default, DataType.U64_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I32_Default) \
+    .dtype_format(DataType.I64_Default, DataType.I64_Default) \
+    .get_op_info()
+
+
+@op_info_register(generate_eod_mask_op_info)
+def _generate_eod_mask_aicpu():
+    """GenerateEodMask AiCPU register"""
+    return

mindspore/ops/function/array_func.py

@@ -268,7 +268,7 @@ def cat(tensors, axis=0):
 
     Returns:
         Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
-            The data type is the same with `tensors`.
+        The data type is the same with `tensors`.
 
     Raises:
         TypeError: If `axis` is not an int.
@@ -660,7 +660,7 @@ def one_hot(indices, depth, on_value=1, off_value=0, axis=-1):
 
     Note:
         If the input indices is rank `N`, the output will have rank `N+1`. The new axis is created at dimension `axis`.
-        On Ascend, if `on_value` is Int64 dtype, `indices` must be Int64 dtype.
+        On Ascend, if `on_value` is int64 dtype, `indices` must be int64 dtype.
 
     Args:
         indices(Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
@@ -4228,6 +4228,7 @@ def space_to_batch_nd(input_x, block_size, paddings):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> block_size = [2, 2]
         >>> paddings = [[0, 0], [0, 0]]
@@ -5395,8 +5396,8 @@ def masked_select(input, mask):
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore.ops as ops
-        >>> from mindspore import Tensor
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int64)
         >>> mask = Tensor(np.array([1, 0, 1, 0]), mindspore.bool_)
         >>> output = ops.masked_select(x, mask)
@@ -6520,7 +6521,7 @@ def topk(input, k, dim=None, largest=True, sorted=True):
 
     Args:
         input (Tensor): Input to be computed, data type must be float16, float32 or int32.
-        k (int): The number of top or bottom elements to be computed along the last dimension, constant input is needed.
+        k (int): The number of top or bottom elements to be computed along the last dimension.
         dim (int, optional): The dimension to sort along. Default: ``None`` .
         largest (bool, optional): If largest is ``False``  then the k smallest elements are returned.
             Default: ``True`` .

mindspore/ops/function/debug_func.py

@@ -51,7 +51,7 @@ def print_(*input_x):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.ones([2, 1]).astype(np.int32))
         >>> y = Tensor(np.ones([2, 2]).astype(np.int32))
         >>> result = ops.print_('Print Tensor x and Tensor y:', x, y)

mindspore/ops/function/linalg_func.py

@@ -59,6 +59,8 @@ def cond(A, p=None):
 
     Args:
         A (Tensor): Tensor of shape :math:`(*, n)` or :math:`(*, m, n)` where * is zero or more batch dimensions.
+            If `p` is one of Union[1, -1, inf, -inf, 'fro', 'nuc'], the function uses
+            :class:`mindspore.ops.MatrixInverse` , therefore, :math:`(*, m, n)` has to be square and ivertible.
         p (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. Refer to the table above for
             behavior. Default: ``None``.
 
@@ -84,8 +86,8 @@ def cond(A, p=None):
     matrix_inverse = _get_cache_prim(P.MatrixInverse)(adjoint=False)
     if p is None:
         p = 2
-    norm_a = F.norm(A, p)
-    norm_inv_a = F.norm(matrix_inverse(A), p)
+    norm_a = F.matrix_norm(A, p)
+    norm_inv_a = F.matrix_norm(matrix_inverse(A), p)
     return norm_a * norm_inv_a
 
 
@@ -194,6 +196,8 @@ def geqrf(input):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
         >>> input_x = Tensor(np.array([[-2.0, -1.0], [1.0, 2.0]]).astype(np.float32))
         >>> y, tau = ops.geqrf(input_x)
         >>> print(y)
@@ -266,6 +270,16 @@ def svd(input, full_matrices=False, compute_uv=True):
     return s
 
 
+def _check_pinv_shape(x):
+    if not isinstance(x, (Tensor, Tensor_)):
+        raise TypeError("The input x must be tensor")
+    if x.shape == ():
+        raise TypeError("For pinv, the 0-D input is not supported")
+    x_shape = F.shape(x)
+    if len(x_shape) < 2:
+        raise ValueError("input x should have 2 or more dimensions, " f"but got {len(x_shape)}.")
+
+
 def pinv(x, *, atol=None, rtol=None, hermitian=False):
     r"""
     Computes the (Moore-Penrose) pseudo-inverse of a matrix.
@@ -318,19 +332,15 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
         ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([[4., 0.], [0., 5.]], mindspore.float32)
         >>> output = ops.pinv(x)
         >>> print(output)
-        [[0.25  0. ]
-        [0.  0.2 ]]
+        [[0.25 0.  ]
+         [0.   0.2 ]]
     """
-    if not isinstance(x, (Tensor, Tensor_)):
-        raise TypeError("The input x must be tensor")
-    if x.shape == ():
-        raise TypeError("For pinv, the 0-D input is not supported")
-    x_shape = F.shape(x)
-    if len(x_shape) < 2:
-        raise ValueError("input x should have 2 or more dimensions, " f"but got {len(x_shape)}.")
+    _check_pinv_shape(x)
     x_dtype = _get_cache_prim(P.DType)()(x)
     _check_input_dtype("x", x_dtype, [mstype.float32, mstype.float64], "pinv")
     _check_attr_dtype("hermitian", hermitian, [bool], "pinv")

mindspore/ops/function/math_func.py

@@ -343,6 +343,7 @@ def add(input, other):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> # case 1: x and y are both Tensor.
         >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
@@ -12784,6 +12785,7 @@ def count_nonzero(x, axis=(), keep_dims=False, dtype=mstype.int32):
     Examples:
         >>> from mindspore import Tensor, ops
         >>> import numpy as np
+        >>> import mindspore
         >>> # case 1: each value specified.
         >>> x = Tensor(np.array([[0, 1, 0], [1, 1, 0]]).astype(np.float32))
         >>> nonzero_num = ops.count_nonzero(x=x, axis=[0, 1], keep_dims=True, dtype=mindspore.int32)
@@ -13392,6 +13394,7 @@ def batch_dot(x1, x2, axes=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> import numpy as np
         >>> x1 = Tensor(np.ones(shape=[2, 2, 3]), mindspore.float32)

mindspore/ops/function/nn_func.py

@@ -2748,6 +2748,7 @@ def softshrink(x, lambd=0.5):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
         >>> from mindspore import Tensor
         >>> from mindspore import ops
         >>> import numpy as np
@@ -3000,11 +3001,12 @@ def dense(input, weight, bias=None):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
-        >>> input = mindspore.Tensor([[-1., 1., 2.], [-3., -3., 1.]], mindspore.float32)
-        >>> weight = mindspore.Tensor([[-2., -2., -2.], [0., -1., 0.]], mindspore.float32)
-        >>> bias = mindspore.Tensor([0., 1.], mindspore.float32)
-        >>> output = mindspore.ops.dense(input, weight, bias)
+        >>> input = Tensor([[-1., 1., 2.], [-3., -3., 1.]], mindspore.float32)
+        >>> weight = Tensor([[-2., -2., -2.], [0., -1., 0.]], mindspore.float32)
+        >>> bias = Tensor([0., 1.], mindspore.float32)
+        >>> output = ops.dense(input, weight, bias)
         >>> print(output)
         [[-4.  0.]
          [10.  4.]]
@@ -3992,8 +3994,8 @@ def l1_loss(input, target, reduction='mean'):
     Examples:
         >>> from mindspore import Tensor, ops
         >>> from mindspore import dtype as mstype
-        >>> x = ms.Tensor([[1, 2, 3], [4, 5, 6]], mstype.float32)
-        >>> target = ms.Tensor([[6, 5, 4], [3, 2, 1]], mstype.float32)
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6]], mstype.float32)
+        >>> target = Tensor([[6, 5, 4], [3, 2, 1]], mstype.float32)
         >>> output = ops.l1_loss(x, target, reduction="mean")
         >>> print(output)
         3.0
@@ -5342,7 +5344,7 @@ def conv1d(input, weight, bias=None, stride=1, pad_mode="valid", padding=0, dila
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.arange(64).reshape((4, 4, 4)), mindspore.float32)
         >>> weight = Tensor(np.arange(8).reshape((2, 2, 2)), mindspore.float32)
-        >>> bias = Tensor([-0.12345, 2.7683], ms.float32)
+        >>> bias = Tensor([-0.12345, 2.7683], mindspore.float32)
         >>> output = ops.conv1d(x, weight, pad_mode='pad', padding=(1,), bias=bias, groups=2)
         >>> print(output.shape)
         (4, 2, 5)
@@ -7444,8 +7446,8 @@ def max_pool2d(x, kernel_size, stride=None, padding=0, dilation=1, return_indice
     return out
 
 
-def prompt_flash_attention(query, key, value, padding_mask, attn_mask, actual_seq_lengths,
-                           actual_seq_lengths_kv, deq_scale1, quant_scale1,
+def prompt_flash_attention(query, key, value, attn_mask, actual_seq_lengths,
+                           actual_seq_lengths_kv, pse_shift, deq_scale1, quant_scale1,
                            deq_scale2, quant_scale2, quant_offset2, num_heads, scale_value=1.0, pre_tokens=2147483547,
                            next_tokens=0, input_layout='BSH',
                            num_key_value_heads=0, sparse_mode=0):
@@ -7468,11 +7470,11 @@ def prompt_flash_attention(query, key, value, padding_mask, attn_mask, actual_se
           Input tensor of shape :math:`(B, S, H)` / `(B, N, S, D)`.
         value (Tensor) - The value tensor with data type of float16 or float32.
           Input tensor of shape :math:`(B, S, H)` / `(B, N, S, D)`.
-        padding_mask (Tensor) - The padding mask tensor with data type of float16 or float32
         attn_mask (Tensor) - The attention mask tensor with data type of float16 or float32.
           For each element, 0 indicates retention and 1 indicates discard. Input tensor of shape :math:`(B, 1, S, S)`.
         actual_seq_lengths (list[int]): Describe actual sequence length of each input with data type of int.
         actual_seq_lengths_kv (list[int]): Describe actual sequence length of each input with data type of int.
+        pse_shift (Tensor) - The position encoding tensor with data type of float16 or float32.
         dep_scale1 (Tensor)
         quant_scale1 (Tensor)
         deq_scale2 (Tensor)
@@ -7516,7 +7518,7 @@ def prompt_flash_attention(query, key, value, padding_mask, attn_mask, actual_se
 
     pfa = _get_cache_prim(NN_OPS.PromptFlashAttention)(num_heads, scale_value, pre_tokens, next_tokens, input_layout,
                                                        num_key_value_heads, sparse_mode)
-    return pfa(query, key, value, padding_mask, attn_mask, actual_seq_lengths, actual_seq_lengths_kv, deq_scale1,
+    return pfa(query, key, value, attn_mask, actual_seq_lengths, actual_seq_lengths_kv, pse_shift, deq_scale1,
                quant_scale1, deq_scale2, quant_scale2, quant_offset2)