mindspore 2.2.14__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc2__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/composite/multitype_ops/zeros_like_impl.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 
-"""Implementation for internal polymorphism `zeros_like_leaf` operations."""
+"""Implementation for internal polymorphism `zeros_like` operations."""
 
 from __future__ import absolute_import
 from mindspore.ops.composite import base
@@ -21,9 +21,9 @@ from mindspore.ops import functional as F
 from mindspore.ops.operations import _sequence_ops as seq
 from mindspore.ops.primitive import Primitive
 
-zeros_like_leaf = base.MultitypeFuncGraph('zeros_like_leaf', True)
+zeros_like_leaf = base.MultitypeFuncGraph('zeros_like', True)
 """
-`zeros_like_leaf` is a metafuncgraph object which will generate a tensor filled with one according to its input type
+`zeros_like` is a metafuncgraph object which will generate a tensor filled with one according to its input type
 using ".register" decorator.
 """
 
@@ -41,16 +41,19 @@ def _zeros_like_bool(x):
     """Returns False if x is a bool."""
     return False
 
+
 @zeros_like_leaf.register("String")
 def _zeros_like_string(x):
     """Returns False if x is a string."""
     return 0
 
+
 @zeros_like_leaf.register("Tuple")
 def _zeros_like_tuple(x):
     """Returns False if x is a tuple."""
     return 0
 
+
 @zeros_like_leaf.register("Function")
 def _zeros_like_func(x):
     """

mindspore/ops/deprecated.py

@@ -69,7 +69,10 @@ class BNTrainingUpdate(Primitive):
 
 class MaxPoolWithArgmax(Primitive):
     """
-    Please use MaxPoolWithArgmaxV2 instead.
+    Please use :class:`mindspore.ops.MaxPoolWithArgmaxV2` instead.
+
+    Supported Platforms:
+        Deprecated
     """
     @deprecated("2.0", "ops.MaxPoolWithArgmaxV2", False)
     @prim_attr_register
@@ -105,7 +108,6 @@ class DropoutGenMask(Primitive):
     @prim_attr_register
     def __init__(self, Seed0=0, Seed1=0):
         """Initialize DropoutGenMask."""
-        super().__init__(name="DropoutGenMask")
         self.init_prim_io_names(inputs=['shape', 'keep_prob'], outputs=['output'])
         validator.check_value_type("Seed0", Seed0, [int], self.name)
         validator.check_value_type("Seed1", Seed1, [int], self.name)
@@ -159,7 +161,10 @@ class TensorAdd(_MathBinaryOp):
 
 class InplaceUpdate(Primitive):
     """
-    Please use InplaceUpdateV2 instead.
+    Please use :class:`mindspore.ops.InplaceUpdateV2` instead.
+
+    Supported Platforms:
+        Deprecated
     """
     @deprecated("2.0", "ops.InplaceUpdateV2", False)
     @prim_attr_register
@@ -239,6 +244,9 @@ class Unpack(Primitive):
 class ScatterNonAliasingAdd(Primitive):
     """
     Please use TensorScatterAdd instead.
+
+    Supported Platforms:
+        Deprecated
     """
     __mindspore_signature__ = (
         sig.make_sig('input_x', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
@@ -257,6 +265,9 @@ class ScatterNonAliasingAdd(Primitive):
 class BatchToSpaceND(Primitive):
     """
     Please use batch_to_space_nd instead.
+
+    Supported Platforms:
+        Deprecated
     """
     @deprecated("2.0", "ops.batch_to_space_nd", False)
     @prim_attr_register

mindspore/ops/extend/__init__.py

@@ -0,0 +1,54 @@
+# Copyright 2020 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.
+# ============================================================================
+
+"""
+
+Operators with better performance
+
+"""
+
+from __future__ import absolute_import
+
+from mindspore.common import Tensor
+from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register
+from mindspore.ops.vm_impl_registry import get_vm_impl_fn, vm_impl_registry
+from mindspore.ops.op_info_register import op_info_register, custom_info_register, AkgGpuRegOp, AkgAscendRegOp, \
+    AiCPURegOp, TBERegOp, CpuRegOp, CustomRegOp, DataType
+from mindspore.ops.primitive import constexpr
+from . import (
+    array_func,
+    math_func,
+    nn_func,
+)
+
+from .array_func import gather, max, min, one_hot, narrow
+from .math_func import (
+    baddbmm,
+    bmm,
+    add,
+    sub
+)
+
+from .nn_func import (
+    conv2d,
+    max_pool2d,
+    leaky_relu_ext,
+    batch_norm
+)
+
+__all__ = []
+__all__.extend(array_func.__all__)
+__all__.extend(math_func.__all__)
+__all__.extend(nn_func.__all__)

mindspore/ops/extend/array_func.py

@@ -0,0 +1,259 @@
+# Copyright 2024 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.
+# ============================================================================
+
+"""
+
+Array Operators
+
+"""
+from mindspore.common import Tensor
+from mindspore.ops.operations.array_ops import ArgMaxWithValue, ArgMinWithValue
+from mindspore.ops._primitive_cache import _get_cache_prim
+from mindspore.ops.auto_generate.gen_ops_prim import gather_d_op, slice_ext_op, OneHotExt
+from mindspore.ops.auto_generate.gen_ops_def import max_, min_
+from mindspore import _checkparam as validator
+
+
+# define Primitive global variables
+def narrow(input, dim, start, length):
+    """
+    Returns a narrowed tensor from input tensor, and
+    the dimension axis is input from start to start + length.
+
+    Args:
+        input (Tensor): the tensor to narrow.
+        dim (int): dimension  along which to narrow.
+        start (int): the starting dimension.
+        length (int): the distance to the ending dimension.
+
+    Returns:
+        Tensor.
+
+        - output (Tensors) - The narrowed tensor.
+
+    Raises:
+        TypeError: If the input is not a tensor or tuple or list of tensors.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> from mindspore import Tensor
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mindspore.int32)
+        >>> output = ops.narrow(x, 0, 0, 2)
+        >>> print(output)
+        [[ 1 2 3]
+         [ 4 5 6]]
+        >>> output = ops.narrow(x, 1, 1, 2)
+        >>> print(output)
+        [[ 2 3]
+         [ 5 6]
+         [ 8 9]]
+    """
+    validator.check_value_type("input", input, Tensor, "narrow")
+    return slice_ext_op(input, dim, start, start+length, 1)
+
+
+def gather(input, dim, index):
+    r"""
+    Gather data from a tensor by indices.
+
+    .. math::
+        output[(i_0, i_1, ..., i_{dim}, i_{dim+1}, ..., i_n)] =
+        input[(i_0, i_1, ..., index[(i_0, i_1, ..., i_{dim}, i_{dim+1}, ..., i_n)], i_{dim+1}, ..., i_n)]
+
+    .. warning::
+        On Ascend, the behavior is unpredictable in the following cases:
+
+        - the value of `index` is not in the range `[-input.shape[dim], input.shape[dim])` in forward;
+        - the value of `index` is not in the range `[0, input.shape[dim])` in backward.
+
+    Args:
+        input (Tensor): The target tensor to gather values.
+        dim (int): the axis to index along, must be in range `[-input.rank, input.rank)`.
+        index (Tensor): The index tensor, with int32 or int64 data type. An valid `index` should be:
+
+            - `index.rank == input.rank`;
+            - `index.shape[axis] <= input.shape[axis]` where axis goes through all dimensions of `input` except `dim`;
+            - the value of `index` is in range `[-input.shape[dim], input.shape[dim])`.
+
+    Returns:
+        Tensor, has the same type as `input` and the same shape as `index`.
+
+    Raises:
+        ValueError: If the shape of `index` is illegal.
+        ValueError: If `dim` is not in `[-input.rank, input.rank)`.
+        ValueError: If the value of `index` is out of the valid range.
+        TypeError: If the type of `index` is illegal.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
+        >>> index = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
+        >>> output = ops.extend.gather(input, 1, index)
+        >>> print(output)
+        [[-0.1 -0.1]
+        [ 0.5  0.5]]
+    """
+    return gather_d_op(input, dim, index)
+
+
+def max(input, dim=None, keepdim=False):
+    """
+    Calculates the maximum value along with the given dimension for the input tensor.
+
+    Args:
+        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
+        dim (int, optional): The dimension to reduce. Default: ``None`` .
+        keepdim (bool, optional): Whether to reduce dimension, if true, the output will keep same dimension
+            with the input, the output will reduce dimension if false. Default: ``False`` .
+
+    Returns:
+        Tensor if `dim` is the default value ``None`` , the maximum value of input tensor, with the shape :math:`()` ,
+        and same dtype as `input`.
+
+        tuple (Tensor) if `dim` is not the default value ``None`` , tuple of 2 tensors, containing the maximum
+        value of the input tensor along the given dimension `dim` and the corresponding index:
+
+        - **values (Tensor)** - The maximum value of input tensor along the given dimension `dim`, with same dtype as
+          `input`. If `keepdim` is ``True`` , the shape of output tensors is :math:`(input_1, input_2, ...,
+          input_{axis-1}, 1, input_{axis+1}, ..., input_N)` . Otherwise, the shape is :math:`(input_1, input_2, ...,
+          input_{axis-1}, input_{axis+1}, ..., input_N)` .
+        - **index (Tensor)** - The index for the maximum value of the input tensor along the given dimension `dim`, with
+          the same shape as `values`.
+
+    Raises:
+        ValueError: If `dim` is the default value ``None`` and `keepdim` is not ``False`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> y = Tensor(np.array([[0.0, 0.3, 0.4, 0.5, 0.1],
+        ...                      [3.2, 0.4, 0.1, 2.9, 4.0]]), mindspore.float32)
+        >>> output, index = ops.extend.max(y, 0, True)
+        >>> print(output, index)
+        [[3.2 0.4 0.4 2.9 4. ]] [[1 1 0 1 1]]
+    """
+    if dim is None:
+        if keepdim is not False:
+            raise ValueError(f"For 'max', the `keepdim` must be False when the `dim` is None, but got {keepdim}")
+        return max_(input)
+    argmax_with_value_op = _get_cache_prim(ArgMaxWithValue)(dim, keepdim)
+    indices, values = argmax_with_value_op(input)
+    return values, indices
+
+
+def min(input, dim=None, keepdim=False):
+    """
+    Calculates the minimum value along with the given dimension for the input tensor.
+
+    Args:
+        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
+        dim (int, optional): The dimension to reduce. Default: ``None`` .
+        keepdim (bool, optional): Whether to reduce dimension, if true, the output will keep same dimension
+            with the input, the output will reduce dimension if false. Default: ``False`` .
+
+    Returns:
+        Tensor if `dim` is the default value ``None`` , the minimum value of input tensor, with the shape :math:`()` ,
+        and same dtype as `input`.
+
+        tuple (Tensor) if `dim` is not the default value ``None`` , tuple of 2 tensors, containing the minimum value
+        of the input tensor along the given dimension `dim` and the corresponding index:
+
+        - **values (Tensor)** - The minimum value of input tensor along the given dimension `dim`, with same dtype as
+          `input`. If `keepdim` is ``True`` , the shape of output tensors is :math:`(input_1, input_2, ...,
+          input_{axis-1}, 1, input_{axis+1}, ..., input_N)` . Otherwise, the shape is :math:`(input_1, input_2, ...,
+          input_{axis-1}, input_{axis+1}, ..., input_N)` .
+        - **index (Tensor)** - The index for the minimum value of the input tensor along the given dimension `dim`,
+          with the same shape as `values`.
+
+    Raises:
+        ValueError: If `dim` is the default value ``None`` and `keepdim` is not ``False`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
+        >>> output, index = ops.extend.min(x, 0, keepdim=True)
+        >>> print(output, index)
+        [0.0] [0]
+    """
+    if dim is None:
+        if keepdim is not False:
+            raise ValueError(f"For 'min', the `keepdim` must be False when the `dim` is None, but got {keepdim}")
+        return min_(input)
+    argmin_with_value_op = _get_cache_prim(ArgMinWithValue)(dim, keepdim)
+    indices, values = argmin_with_value_op(input)
+    return values, indices
+
+
+def one_hot(tensor, num_classes):
+    r"""
+    Computes a one-hot tensor.
+
+    The locations represented by tensor in `tensor` take value `1`, while all
+    other locations take value `0`.
+
+    Args:
+        tensor (Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
+            Data type must be int32 or int64.
+        num_classes (Union[int, Tensor]): A scalar defining the depth of the one-hot dimension.
+
+    Returns:
+        Tensor, one-hot tensor.
+
+    Raises:
+        TypeError: If `num_classes` is not an int.
+        TypeError: If dtype of `tensor` is not int32 or int64.
+        ValueError: If `num_classes` is less than 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor
+        >>> tensor = Tensor(np.array([0, 1, 2]), mindspore.int32)
+        >>> num_classes = 3
+        >>> output = ops.extend.one_hot(tensor, num_classes)
+        >>> print(output)
+        [[1. 0. 0.]
+        [0. 1. 0.]
+        [0. 0. 1.]]
+    """
+    on_value = Tensor(1, dtype=tensor.dtype)
+    off_value = Tensor(0, dtype=tensor.dtype)
+    onehot = _get_cache_prim(OneHotExt)(-1)
+    return onehot(tensor, num_classes, on_value, off_value)
+
+
+__all__ = ['gather', 'max', 'min', 'one_hot']

mindspore/ops/extend/math_func.py

@@ -0,0 +1,76 @@
+# 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.
+# ============================================================================
+
+"""
+
+Math Operators with better performance
+
+"""
+
+from mindspore.ops import auto_generate as P
+from mindspore.ops.auto_generate.gen_ops_def import add_ext as add, sub_ext as sub, bmm_ext as bmm
+
+
+# define Primitive global variables
+
+
+def baddbmm(input, batch1, batch2, beta=1, alpha=1):
+    r"""
+    The result is the sum of the input and a batch matrix-matrix product of matrices in batch1 and batch2.
+    The formula is defined as follows:
+
+    .. math::
+        \text{out}_{i} = \beta \text{input}_{i} + \alpha (\text{batch1}_{i} \mathbin{@} \text{batch2}_{i})
+
+    Args:
+        input (Tensor): The input Tensor. When batch1 is a :math:`(C, W, T)` Tensor and batch2 is a
+            :math:`(C, T, H)` Tensor, input must be broadcastable with :math:`(C, W, H)` Tensor.
+        batch1 (Tensor): :math:`batch1` in the above formula. Must be 3-D Tensor, dtype is same as input.
+        batch2 (Tensor): :math:`batch2` in the above formula. Must be 3-D Tensor, dtype is same as input.
+        beta (Union[float, int], optional): multiplier for input. Default: ``1`` .
+        alpha (Union[float, int], optional): multiplier for :math:`batch1 @ batch2`. Default: ``1`` .
+            Arguments beta and alpha must be integers when inputs of type not FloatTensor, otherwise they should
+            be a real number.
+
+    Returns:
+        Tensor, has the same dtype as input, shape will be :math:`(C, W, H)`.
+
+    Raises:
+        TypeError: The type of `input`, `batch1`, `batch2` is not Tensor.
+        TypeError: The types of `input`, `batch1`, `batch2` are different.
+        TypeError: For inputs of type FloatTensor or DoubleTensor, \
+                    arguments beta and alpha not be real numbers, otherwise not be integers.
+        TypeError: For Baddbmm, attributes alpha and beta are not real numbers
+        ValueError: If `batch1` and `batch2` are not 3-D tensors.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.ones([1, 3, 3]).astype(np.float32))
+        >>> batch1 = Tensor(np.ones([1, 3, 4]).astype(np.float32))
+        >>> batch2 = Tensor(np.ones([1, 4, 3]).astype(np.float32))
+        >>> output = ops.baddbmm(input, batch1, batch2)
+        >>> print(output)
+        [[[5. 5. 5.]
+          [5. 5. 5.]
+          [5. 5. 5.]]]
+    """
+    return P.baddbmm(input, batch1, batch2, beta, alpha)
+
+
+__all__ = ['baddbmm', 'add', 'sub', 'bmm']