mindspore 2.3.0rc1__cp38-none-any.whl → 2.3.0rc2__cp38-none-any.whl

mindspore/ops/operations/nn_ops.py

@@ -30,11 +30,14 @@ from mindspore.ops.primitive import Primitive
 from mindspore.ops.primitive import PrimitiveWithInfer
 from mindspore.ops.primitive import PrimitiveWithCheck
 from mindspore.ops.primitive import prim_attr_register
-from ..auto_generate import (CeLU, Flatten, LogSoftmax, ReLU, ReLU6,
-                             Elu, Sigmoid, Softmax, HSwish, HSigmoid, AvgPool, BiasAdd,
+from ..auto_generate import (CeLU, Flatten, LogSoftmax, ReLU, ReLU6, Dense,
+                             Elu, Sigmoid, Softmax, SoftplusExt, HSwish, HSigmoid, AvgPool, BiasAdd,
                              NLLLoss, OneHot, GeLU, FastGeLU, PReLU,
-                             GridSampler3D, GridSampler2D, LayerNorm, HShrink, AdamWeightDecay, Dropout,
-                             ApplyRotaryPosEmb, PagedAttention, PagedAttentionMask, ReshapeAndCache)
+                             GridSampler3D, GridSampler2D, LayerNorm, LayerNormExt, HShrink, AdamWeightDecay, Dropout,
+                             ApplyRotaryPosEmb, PagedAttention, PagedAttentionMask, ReshapeAndCache,
+                             FlashAttentionScore, Embedding, UpsampleNearest1D, UpsampleNearest2D,
+                             UpsampleNearest3D, UpsampleTrilinear3D,
+                             UpsampleBilinear2D, UpsampleLinear1D)
 from .manually_defined import BatchNorm
 
 
@@ -449,7 +452,7 @@ class ReLUV3(Primitive):
     Inputs:
         - **input_x** (Tensor) - Tensor of shape :math:`(N, *)`, where :math:`*` means, any number of
           additional dimensions, data type is
-          `number <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
 
     Outputs:
         Tensor of shape :math:`(N, *)`, with the same type and shape as the `input_x`.
@@ -3038,84 +3041,6 @@ class L2Normalize(Primitive):
         self.axis = axis
 
 
-class UpsampleTrilinear3D(Primitive):
-    r"""
-    Performs upsampling with trilinear interpolation across 3dims for 5dim input Tensor.
-
-    This operator scale up the volumetric input with specified `output_size` or `scales` factors,
-    using trilinear upscaling algorithm.
-
-    Note:
-        One of `scales` and `output_size` must be specified. And it is an error if both are specified.
-
-    Args:
-        align_corners (bool, optional): An optional bool. Default: ``False``.
-            If ``True``, the input and output tensors are aligned by the center points of their corner pixels,
-            preserving the values at the corner pixels.
-            If ``False`` , the input and output tensors are aligned by the corner points of their corner pixels,
-            and the interpolation use edge value padding for out of boundary values.
-
-    Inputs:
-        - **x** (Tensor) - 5D tensor of shape :math:`(N, C, D_{in}, H_{in}, W_{in})`. Supporting types:
-          [float16, float32, float64].
-        - **output_size** (Union[tuple[int], list[int]]):  A tuple or list of 3 int elements
-          :math:`(output\_depth, output\_height, output\_width)`. Default: ``None``.
-        - **scales** (Union[tuple[float], list[float]]): A tuple or list of 3 float
-          elements :math:`(scale\_depth, scale\_height, scale\_width)`. Default: ``None``.
-
-    Outputs:
-        - **y** (Tensor) - Upsampled output with the same data type as `x`, whose shape is
-          :math:`(N, C, D_{out}, H_{out}, W_{out})`.
-
-    Raises:
-        TypeError: When `output_size` is not ``None`` and `output_size` is not list[int] or tuple[int].
-        TypeError: When `scales` is not ``None`` and `scales` is not list[float] or tuple[float].
-        TypeError: If dtype of `x` is not in [float16, float32, float64].
-        TypeError: If type of `align_corners` is not bool.
-        ValueError: If any value of `output_size` is negative or zero when `output_size` is not ``None``.
-        ValueError: If any value of `scales` is negative or zero when `scales` is not ``None``.
-        ValueError: If shape of `x` is not 5D.
-        ValueError: If none of `scales` and `output_size` is specified or both specified.
-        ValueError: If size of `scales` is not equal 3 when `scales` is specified.
-        ValueError: If size of `output_size` is not equal 3 when `output_size` is specified.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> net = ops.UpsampleTrilinear3D()
-        >>> in_x = Tensor(input_data=np.random.randn(2, 3, 4, 512, 256))
-        >>> output_size=[4, 64, 48]
-        >>> out = net(in_x, output_size, None)
-        >>> print(out.shape)
-        (2, 3, 4, 64, 48)
-        >>>
-        >>> net = ops.UpsampleTrilinear3D()
-        >>> in_x = Tensor(np.arange(1, 5, dtype=np.float32).reshape((1, 1, 1, 2, 2)))
-        >>> output_size=[2, 4, 4]
-        >>> out = net(in_x, output_size, None)
-        >>> print(out)
-        [[[[[1.   1.25 1.75 2.  ]
-            [1.5  1.75 2.25 2.5 ]
-            [2.5  2.75 3.25 3.5 ]
-            [3.   3.25 3.75 4.  ]]
-           [[1.   1.25 1.75 2.  ]
-            [1.5  1.75 2.25 2.5 ]
-            [2.5  2.75 3.25 3.5 ]
-            [3.   3.25 3.75 4.  ]]]]]
-    """
-
-    @prim_attr_register
-    def __init__(self, align_corners=False):
-        """Initialize UpsampleTrilinear3D."""
-        self.init_prim_io_names(inputs=['x', 'output_size', 'scales'], outputs=['y'])
-        self.align_corners = align_corners
-        validator.check_bool(self.align_corners, "align_corners", self.name)
-        self.add_prim_attr('align_corners', self.align_corners)
-
-
 class GetNext(Primitive):
     """
     Returns the next element in the dataset queue.
@@ -6378,6 +6303,7 @@ class DynamicRNN(Primitive):
         self.forget_bias = validator.check_value_type("forget_bias", forget_bias, [float], self.name)
         self.use_peephole = validator.check_value_type("use_peephole", use_peephole, [bool], self.name)
         self.time_major = validator.check_value_type("time_major", time_major, [bool], self.name)
+        validator.check("time_major", time_major, "the supported value", True, validator.EQ, self.name)
         self.is_training = validator.check_value_type("is_training", is_training, [bool], self.name)
         validator.check_value_type("cell_type", cell_type, [str], self.name)
         self.cell_type = validator.check_string(cell_type, ['LSTM'], "cell_type", self.name)
@@ -9090,71 +9016,6 @@ class Pdist(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
 
-class UpsampleNearest3D(Primitive):
-    r"""
-    Performs nearest neighbor upsampling operation.
-
-    This operator scale up the volumetric input with specified `output_size` or `scales` factors, using nearest
-    neighbor algorithm.
-
-    One of `output_size` or `scales` must be given, and can not specified both at the same time.
-
-    Inputs:
-        - **x** (Tensor) - 5D tensor of shape :math:`(N, C, D_{in}, H_{in}, W_{in})`.
-          Supporting types: [float16, float32, float64].
-        - **output_size** (Union[tuple[int], list[int]]): A tuple or list of int specifying the output volumetric size.
-          Default: ``None``.
-        - **scales** (Union[tuple[float], list[float]]): A tuple or list of float specifying the upsampling factors.
-          Default: ``None``.
-
-    Outputs:
-        - **y** (Tensor) - Upsampled output with the same type as `x` , whose shape is
-          :math:`(N, C, D_{out}, H_{out}, W_{out})`.
-
-    Raises:
-        TypeError: When `output_size` is not ``None`` and `output_size` is not list[int] or tuple[int].
-        TypeError: When `scales` is not ``None`` and `scales` is not list[float] or tuple[float].
-        TypeError: If dtype of `x` is not int [uint8, float16, float32, float64].
-        ValueError: If any value of `output_size` is negative or zero when `output_size` is not ``None``.
-        ValueError: If any value of `scales` is negative or zero when `scales` is not ``None``.
-        ValueError: If shape of `x` is not 5D.
-        ValueError: If none of `scales` and `output_size` is specified or both specified.
-        ValueError: If size of `scales` is not equal 3 when `scales` is specified.
-        ValueError: If size of `output_size` is not equal 3 when `output_size` is specified.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> x = Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
-        ...       .reshape([1, 1, 2, 2, 4]), mstype.float32)
-        >>> output_size = [3, 4, 5]
-        >>> net = ops.UpsampleNearest3D()
-        >>> output = net(x, output_size, None)
-        >>> print(output)
-        [[[[[ 1.  1.  2.  3.  4.]
-            [ 1.  1.  2.  3.  4.]
-            [ 5.  5.  6.  7.  8.]
-            [ 5.  5.  6.  7.  8.]]
-           [[ 1.  1.  2.  3.  4.]
-            [ 1.  1.  2.  3.  4.]
-            [ 5.  5.  6.  7.  8.]
-            [ 5.  5.  6.  7.  8.]]
-           [[ 9.  9. 10. 11. 12.]
-            [ 9.  9. 10. 11. 12.]
-            [13. 13. 14. 15. 16.]
-            [13. 13. 14. 15. 16.]]]]]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize UpsampleNearest3D."""
-        self.init_prim_io_names(inputs=['x', 'output_size', 'scales'], outputs=['y'])
-
-
 class SparseApplyAdagradDA(Primitive):
     r"""
     Update `var` according to the proximal adagrad scheme.
@@ -9797,54 +9658,6 @@ class MaxPoolWithArgmaxV2(Primitive):
         self.add_prim_attr("ceil_mode", self.ceil_mode)
 
 
-class Dense(Primitive):
-    r"""
-    The dense connected fusion operator.
-
-    Applies dense connected operator for the input. The implement of the operation is as:
-
-    .. math::
-        output = x @ w ^ T + b,
-
-    where :math:`x` is the input tensor, :math:`w` is a weight matrix with the same data type as the :math:`x` ,
-    and :math:`b` is a bias vector with the same data type as the :math:`x` (only if `b` is not ``None``).
-
-    Inputs:
-        - **x** (Tensor) - The shape must meet the following requirement: :math:`len(x.shape)>0`.
-        - **w** (Tensor) - The shape must meet the following requirements:
-          If :math:`len(x.shape)>1`, :math:`len(w.shape)=2`. If :math:`len(x.shape)=1`, :math:`len(w.shape)=1`.
-          :math:`w.shape[-1]=x.shape[-1]`.
-        - **b** (Union[Tensor, None]) - If `b` is not ``None``, the shape must meet the following requirements:
-          If :math:`len(x.shape)>1`, :math:`len(b.shape)=0` or :math:`len(b.shape)=1` .
-          If :math:`len(b.shape)=1`, :math:`b.shape[0]=w.shape[0]`.
-          If :math:`len(x.shape)=1`, :math:`len(b.shape)=0`.
-
-    Outputs:
-        If :math:`len(x.shape)>1`, Tensor of shape :math:`(*x.shape[:-1], w.shape[0])`.
-        If :math:`len(x.shape)=1`, Tensor of shape :math:`()`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.random.random((4, 5, 6, 7)).astype(np.float32))
-        >>> weight = Tensor(np.random.random((6, 7)).astype(np.float32))
-        >>> bias = Tensor(np.random.random((6,)).astype(np.float32))
-        >>> dense = ops.Dense()
-        >>> output = dense(x, weight, bias)
-        >>> print(output.shape)
-        (4, 5, 6, 6)
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Dense."""
-        self.init_prim_io_names(inputs=['x', 'w', 'b'], outputs=["output"])
-        self.add_prim_attr("has_bias", True)
-
-
 class WKV(Primitive):
     r"""
     The WKV computation is similar to AFT(Zhai et al., 2021), but W is now a channel-wise vector multiplied
@@ -10052,115 +9865,6 @@ class IncreFlashAttention(Primitive):
                                 outputs=["attention_out"])
 
 
-class FlashAttentionScore(Primitive):
-    r"""
-    FlashAttentionScore.
-    .. math::
-        \begin{array}{ll} \\
-            y = Dropout(Softmax(Mask(scale_value \mul (real_shift + query * key), attn_mask), -1), keep_prob) \\
-            \mul value \\
-        \end{array}
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-    B -- Batch size
-    S1 -- Sequence length of query. The value ranges from 1 to 32768 and is a multiple of 16.
-    S2 -- Sequence length of key and value. The value ranges from 1 to 32768 and is a multiple of 16.
-    N1 -- Num heads of query
-    N2 -- Num heads of key and value, and N2 must be a factor of N1
-    D -- Head size. Support value: 64, 80, 96, 120, 128 and 256.
-    H1 -- Hidden size of query, which equals to N1 * D
-    H2 -- Hidden size of key and value, which equals to N2 * D
-    Args:
-        head_num (int): The head num of query. Default: 1.
-        keep_prob (float): The keep probability of dropout. Default: 1.0.
-        scale_value (float): The scale factor of score. Default: 1.0.
-        pre_tokens (int): Parameter for sparse computation, represents how many tokens are counted forward.
-        When sparse_mode is set to 1, 2, 3, or 5, this parameter does not take effect. Default: 2147483647.
-        next_tokens (int): Parameter for sparse computation, represents how many tokens are counted backward.
-        When sparse_mode is set to 1, 2, 3, or 5, this parameter does not take effect. Default: 2147483647.
-        inner_precise (int): The parameter is reserved and not implemented yet. Default: 0.
-        input_layout (str): Specifies the layout of input `query`, key and value. The value can be "BSH" or "BNSD".
-        Default: "BSH".
-        sparse_mode (int): Indicates sparse mode. Default 0.
-
-            - 0: Indicates the defaultMask mode. If attn_mask is not passed, the mask operation is not performed,
-              and preTokens and nextTokens(internally assigned as INT_MAX) are ignored. If passed in, the full attn_mask
-              matrix (S1 * S2) needs to be passed in, indicating that the part between preTokens and nextTokens needs to
-              be calculated.
-            - 1: Represents allMask, that is, passing in the complete attn_mask matrix.
-            - 2: Representing the leftUpCausal mode corresponds to the lower triangle scenario divided by the left
-              vertex, and the optimized attn_mask matrix (2048*2048) is required.
-            - 3: Representing the rightDownCausal model corresponds to the lower triangle scene divided by the lower
-              right vertex, and the optimized attn_mask matrix (2048*2048) is required.
-            - 4: Represents the band scenario, that is, the part between counting preTokens and nextTokens, and the
-              optimized attn_mask matrix (2048*2048) is required..
-            - 5: Represents the prefix scenario, that is, on the basis of rightDownCasual, a matrix with length S1 and
-              width N is added to the left side. The value of N is obtained by the new input prefix, and the N value of
-              each Batch axis is different. Not implemented yet.
-            - 6: Represents the global scenario, not implemented yet.
-            - 7: Represents the dilated scenario, not implemented yet.
-            - 8: Represents the block_local scenario, not implemented yet.
-
-    Inputs:
-        - **query** (Tensor[float16, bfloat16]) - The query tensor.
-          Input tensor of shape :math:`(B, S1, H1)` or `(B, N1, S1, D)`.
-        - **key** (Tensor[float16, bfloat16]) - The key tensor.
-          Input tensor of shape :math:`(B, S2, H2)` or `(B, N2, S2, D)`.
-        - **value** (Tensor[float16, bfloat16]) - The value tensor.
-          Input tensor of shape :math:`(B, S2, H2)` or `(B, N2, S2, D)`.
-        - **real_shift** (Union[Tensor[float16, bfloat16], None]) - The position embedding code. If S is greater than
-          1024 and the mask of the lower triangle is used, enter only the inverse 1024 lines of the lower triangle for
-          memory optimization.
-          Input tensor of shape :math: `(B, N1, S1, S2)`, `(1, N1, S1, S2)`, `(B, N1, 1024, S2)`, `(1, N1, 1024, S2)`
-          or (1024, 1024).
-        - **drop_mask** (Union[Tensor[uint8], None]) - The dropout mask tensor.
-          Input tensor of shape :math:`(B, N1, S1, S2 // 8) or None`.
-        - **padding_mask** (None) - Reserved parameter. Not implemented yet.
-        - **attn_mask** (Union[Tensor[uint8], None]) - The attention mask tensor. For each element, 0 indicates
-          retention and 1 indicates discard. Input tensor of shape :math:`(B, N1, S1, S2)`, `(B, 1, S1, S2)`, `(S1, S2)`
-          or (2048, 2048).
-        - **prefix** (Union[Tensor[int64], None]) - N value of each Batch in the prefix sparse calculation scenario.
-          Input tensor of shape :math:`(B,)`.
-
-    Outputs:
-        - **softmax_max** (Tensor[float32]) - (B, N1, S1, 8)
-        - **softmax_sum** (Tensor[float32]) - (B, N1, S1, 8)
-        - **softmax_out** (Tensor[float16, bfloat16]) - Useless output, ignore it. Output tensor of shape : `()`
-        - **attention_out** (Tensor[float16, bfloat16]) - The output of attention, its shape, and data type
-          are the same as the query.
-
-    Supported Platforms:
-        ``Ascend910B``
-    """
-
-    @prim_attr_register
-    def __init__(self, head_num=1, keep_prob=1.0, scale_value=1.0, pre_tokens=2147483647, next_tokens=2147483647,
-                 inner_precise=0, input_layout="BSH", sparse_mode=0):
-        """Initialize FlashAttentionScore"""
-        validator.check_value_type('head_num', head_num, [int], self.name)
-        validator.check_value_type('keep_prob', keep_prob, [int, float], self.name)
-        validator.check_float(keep_prob, 0.0, validator.GE, "keep_prob", self.name)
-        validator.check_float(keep_prob, 1.0, validator.LE, "keep_prob", self.name)
-        validator.check_value_type('scale_value', scale_value, [float], self.name)
-        validator.check_value_type('pre_tokens', pre_tokens, [int], self.name)
-        validator.check_value_type('next_tokens', next_tokens, [int], self.name)
-        validator.check_value_type('inner_precise', inner_precise, [int], self.name)
-        validator.check_value_type('sparse_mode', sparse_mode, [int], self.name)
-        valid_sparse_mode = [0, 1, 2, 3, 4]
-        if sparse_mode not in valid_sparse_mode:
-            raise ValueError(f"Attribute 'sparse_mode' must be one of {valid_sparse_mode}, but got {sparse_mode}")
-        if inner_precise not in [0]:
-            raise ValueError(f"Attribute 'inner_precise' must be 0, but got {inner_precise}")
-        validator.check_value_type('input_layout', input_layout, [str], self.name)
-        support_layout = ["BSH", "BNSD"]
-        if input_layout not in support_layout:
-            raise ValueError(f"Attribute 'input_layout' must be one of {support_layout}, but got {input_layout}")
-        self.init_prim_io_names(
-            inputs=['query', 'key', 'value', 'real_shift', 'drop_mask', 'padding_mask', 'attn_mask', 'prefix'],
-            outputs=['softmax_max', 'softmax_sum', 'softmax_out', 'attention_out'])
-
-
 class RmsNorm(Primitive):
     r"""
     The RmsNorm operator is a normalization operation, and its formula is:
@@ -10196,14 +9900,3 @@ class RmsNorm(Primitive):
         """Initialize Dense."""
         validator.check_value_type("epsilon", epsilon, [float], self.name)
         self.init_prim_io_names(inputs=['x', 'gamma'], outputs=["y", "rstd"])
-
-
-class MatmulQkv(Primitive):
-    r"""
-    Fuse three matmul ops for q k v attention into one
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize"""
-        self.init_prim_io_names(inputs=['hidden_states', 'weight_q', 'weight_k', 'weight_v'],
-                                outputs=["output_q", "output_k", "output_v"])

mindspore/ops/operations/random_ops.py

@@ -20,7 +20,7 @@ from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from mindspore.ops.primitive import PrimitiveWithInfer, prim_attr_register, Primitive
 from mindspore.ops._utils import get_broadcast_shape
-from ..auto_generate import RandpermV2
+from ..auto_generate import RandpermV2, UniformExt
 
 
 class NonDeterministicInts(Primitive):

mindspore/ops/operations/sparse_ops.py

@@ -60,7 +60,7 @@ class SparseDenseCwiseAdd(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore.common.tensor import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.common import dtype as ms
         >>> from mindspore.ops.operations import sparse_ops as ops
         >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
@@ -115,7 +115,7 @@ class SparseDenseCwiseMul(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore.common.tensor import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.common import dtype as ms
         >>> from mindspore.ops.operations import sparse_ops as ops
         >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
@@ -170,7 +170,7 @@ class SparseDenseCwiseDiv(Primitive):
         ``Ascend`` ``GPU``
 
     Examples:
-      >>> from mindspore.common.tensor import Tensor
+      >>> from mindspore import Tensor
       >>> from mindspore.common import dtype as ms
       >>> from mindspore.ops.operations import sparse_ops as ops
       >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)

mindspore/ops/primitive.py

@@ -548,7 +548,7 @@ class PrimitiveWithCheck(Primitive):
     the shape and type. Method infer_value() can also be defined (such as PrimitiveWithInfer) for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html>`_.
+    <https://www.mindspore.cn/tutorials/experts/en/master/operation/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.
@@ -642,7 +642,7 @@ class PrimitiveWithInfer(Primitive):
     logic of the shape and type. The infer_value() is used for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html>`_.
+    <https://www.mindspore.cn/tutorials/experts/en/master/operation/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.

mindspore/ops_generate/arg_dtype_cast.py

@@ -20,17 +20,25 @@ import mindspore as ms
 from mindspore import ops
 from mindspore.common.tensor import Tensor
 from mindspore.ops.operations._sequence_ops import TensorToScalar, TensorToTuple
-from mindspore.ops_generate.gen_ops_inner_prim import ListToTuple, TupleToList
+from mindspore.ops_generate.gen_ops_inner_prim import TupleToList
 from mindspore._c_expression import OpDtype
 
 tensor_to_tuple_ = TensorToTuple()
-list_to_tuple = ListToTuple()
 tuple_to_list = TupleToList()
 
+
 def int_to_float(data):
     return float(data)
 
 
+def list_to_tuple(data):
+    # tuple() currently does not support Any from JIT Fallback.
+    res = ()
+    for element in data:
+        res += (element,)
+    return res
+
+
 def scalar_to_tuple(data):
     return (data,)
 
@@ -61,6 +69,7 @@ def tuple_to_tensor(data):
 def list_to_tensor(data):
     return ops.tuple_to_array(list_to_tuple(data))
 
+
 # There will be some problems in using OpDtype.xxx directly in GRAPH_MODE, so convert it to int.
 # type
 DT_TYPE_VAL = int(OpDtype.DT_TYPE)
@@ -243,6 +252,6 @@ def type_it(op_name, arg_name, data, src_type, dst_type):
     dst_type = int(dst_type)
     if not is_instance_in(data, src_type) and not is_instance_of(data, dst_type):
         support_list = get_support_dtype_list(src_type, dst_type)
-        raise TypeError(f"For '{op_name}', the type of '{arg_name}' should be one of '[{support_list}]', " \
+        raise TypeError(f"For '{op_name}', the type of '{arg_name}' should be one of '[{support_list}]', "
                         f"but got {type(data)}.")
     return do_type_cast(data, dst_type)

mindspore/ops_generate/arg_handler.py

@@ -79,6 +79,30 @@ def to_dilations(op_name, arg_name, dilation):
     raise ValueError(arg_invalid_info(op_name, arg_name, dilation))
 
 
+def to_output_padding(op_name, arg_name, output_padding):
+    """
+    convert output_padding: int/tuple[int*4] -> tuple[int*2].
+    """
+    if isinstance(output_padding, int):
+        return (output_padding, output_padding)
+    if isinstance(output_padding, (tuple, list)):
+        if len(output_padding) == 4:
+            return (output_padding[2], output_padding[3])
+        return output_padding
+    raise ValueError(arg_invalid_info(op_name, arg_name, output_padding))
+
+
+def to_2d_paddings(op_name, arg_name, pad):
+    """
+    convert paddings: int -> tuple[int*2].
+    """
+    if isinstance(pad, int):
+        return (pad,) * 2
+    if isinstance(pad, (tuple, list)):
+        return pad
+    raise ValueError(arg_invalid_info(op_name, arg_name, pad))
+
+
 def to_paddings(op_name, arg_name, pad):
     """
     convert paddings: int -> tuple[int*4].

mindspore/ops_generate/gen_ops_inner_prim.py

@@ -68,6 +68,8 @@ class StringToEnum(Primitive):
 
     def __call__(self, op_name, arg_name, enum_str):
         """Run in PyNative mode"""
+        if enum_str is None:
+            return None
         if not isinstance(enum_str, str):
             raise TypeError(f"For '{op_name}', the input '{arg_name}' should be a str, but got {type(enum_str)}.")
         return op_enum.str_to_enum(op_name, arg_name, enum_str)

mindspore/ops_generate/gen_pyboost_func.py

@@ -203,10 +203,15 @@ def generate_pyboost_op_source_code(work_path, op_proto, template_paths, convert
             customize_include = "#include \"plugin/device/gpu/kernel/pyboost/customize/{}.h\"".format(
                 operator_name.lower())
         elif op_proto.is_view:
+            set_output_abs = "SetOutputAbstract();"
+            if converter.call_func_outputs == "outputs_":
+                set_output_abs = "SetOutputTupleAbstract();"
             call_impl = view_tpl.replace(op_name=op_proto.class_name,
                                          call_args=converter.call_args,
                                          call_tensors=call_args_tensor,
-                                         input=converter.call_args[0])
+                                         return_values=converter.call_func_outputs,
+                                         input=converter.call_args[0],
+                                         set_output_abs=set_output_abs)
             customize_include = "#include \"mindspore/core/ops/view/{}_strides_calc.h\"".format(proto_operator_name)
         else:
             cast_input_code, real_call_args_tensor = generate_tensor_cpu_cast_input_code(
@@ -799,17 +804,19 @@ def gen_pyboost_inner_prim(work_path, op_yaml_data):
         gen_header += template.PYBOOST_PY_FUNC_IMPORT_HEADEAR.replace(class_name=op_proto.class_name)
         args = operator_data.get('args')
         input_args = []
+        processed_args = []
         process_func = ''
         for arg_name, arg_info in args.items():
             arg_handler = arg_info.get('arg_handler')
-            input_arg = arg_name
+            processed_arg = arg_name
             if arg_handler is not None and arg_handler != 'dtype_to_type_id':
                 process_func += f"""converted_{arg_name} = {arg_handler}({arg_name})\n"""
-                input_arg = 'converted_' + arg_name
-            input_args.append(input_arg)
-
+                processed_arg = 'converted_' + arg_name
+            input_args.append(arg_name)
+            processed_args.append(processed_arg)
         gen_py += template.PYTHON_PRIM_TEMPLATE.replace(class_name=op_proto.class_name, input_args=input_args,
-                                                        process_func=process_func, func_impl_name=operator_name)
+                                                        process_func=process_func, func_impl_name=operator_name,
+                                                        processed_args=processed_args)
     dir_path = os.path.join(work_path, "mindspore/python/mindspore/ops/auto_generate")
     pathlib.Path(dir_path).mkdir(parents=True, exist_ok=True)
     dst_file_path = os.path.join(dir_path, "pyboost_inner_prim.py")

mindspore/ops_generate/pyboost_utils.py

@@ -50,22 +50,7 @@ def get_index(index: int):
     :param index:
     :return: str
     """
-    index_map = {
-        0: 'kIndex0',
-        1: 'kIndex1',
-        2: 'kIndex2',
-        3: 'kIndex3',
-        4: 'kIndex4',
-        5: 'kIndex5',
-        6: 'kIndex6',
-        7: 'kIndex7',
-        8: 'kIndex8',
-        9: 'kIndex9',
-        10: 'kIndex10',
-    }
-    if index in index_map:
-        return index_map[index]
-    raise TypeError(f"""Unsupported index {index} for index map.""")
+    return "kIndex" + str(index)
 
 
 def get_convert_type_str(dtype: str, optional):
@@ -226,7 +211,7 @@ def get_input_dtype(dtype: str, optional):
 
 
 def is_cube(class_name):
-    cube_set = {'Bmm', 'Baddbmm', 'MatMul'}
+    cube_set = {'Bmm', 'Baddbmm', 'MatMulExt', 'Mv'}
     if class_name in cube_set:
         return True
     return False

mindspore/parallel/__init__.py

@@ -18,10 +18,11 @@ from __future__ import absolute_import
 from mindspore.parallel.algo_parameter_config import get_algo_parameters, reset_algo_parameters, \
     set_algo_parameters
 from mindspore.parallel.checkpoint_transform import rank_list_for_transform, transform_checkpoint_by_rank, \
-    transform_checkpoints, merge_pipeline_strategys, sync_pipeline_shared_parameters
+    transform_checkpoints, merge_pipeline_strategys, sync_pipeline_shared_parameters, \
+    load_segmented_checkpoints
 from mindspore.parallel.parameter_broadcast import parameter_broadcast
 from mindspore.parallel.shard import shard, Layout
 
 __all__ = ["set_algo_parameters", "reset_algo_parameters", "get_algo_parameters", "rank_list_for_transform",
            "transform_checkpoint_by_rank", "transform_checkpoints", "merge_pipeline_strategys", "shard",
-           "sync_pipeline_shared_parameters", "Layout", "parameter_broadcast"]
+           "sync_pipeline_shared_parameters", "Layout", "parameter_broadcast", "load_segmented_checkpoints"]