# 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.
# ============================================================================
"""mint module."""
from __future__ import absolute_import
import mindspore.ops as ops
from mindspore.ops.extend import gather, conv2d, max, min
from mindspore.ops.extend import array_func, math_func, nn_func
from mindspore.mint.nn.functional import *
from mindspore.mint.nn import functional
from mindspore.mint import linalg
from mindspore.ops import erf, where, triu
from mindspore.ops.function.math_func import linspace_ext as linspace
from mindspore.ops.function.array_func import full_ext as full
from mindspore.ops.function.array_func import ones_like_ext as ones_like
from mindspore.ops.function.array_func import zeros_like_ext as zeros_like
from mindspore.ops.function.array_func import unique_ext as unique
from mindspore.ops.function.math_func import isclose
from mindspore.ops.auto_generate import abs
# 1
from mindspore.ops.function.math_func import divide, div
from mindspore.ops.auto_generate import topk_ext as topk
# 2
from mindspore.ops.function.math_func import sin
# 3
from mindspore.ops.function.clip_func import clamp
# 4
# 5
from mindspore.ops.auto_generate import cumsum_ext as cumsum
# 6
from mindspore.ops.auto_generate import stack_ext as stack
# 7
# 8
# 9
# 10
from mindspore.ops.function.math_func import ne
# 11
# 12
# 13
from mindspore.ops.functional import flip
# 14
# 15
from mindspore.ops.auto_generate import flatten_ext as flatten
# 16
from mindspore.ops.functional import matmul
from mindspore.ops.auto_generate import bmm_ext as bmm
# 17
# 18
from mindspore.ops.functional import sum
# 19
from mindspore.ops.functional import log
# 20
# 21
from mindspore.ops.functional import mul
# 22
# 23
# 24
# 25
from mindspore.ops.functional import greater, gt
# 26
from mindspore.ops.functional import eq
# 27
from mindspore.ops.functional import reciprocal
# 28
from mindspore.ops.functional import exp
# 29
# 30
from mindspore.ops.functional import searchsorted
# 31
# 32
# 33
# 34
# 35
from mindspore.ops.functional import erfinv
# 36
# 37
from mindspore.ops.function.array_func import nonzero
# 38
# 39
# 40
# 41
# 42
from mindspore.ops.function.math_func import argmax_ext as argmax
# 43
# 44
from mindspore.ops.functional import cos
# 45
# 46
# 47
# 48
# 49
# 50
from mindspore.ops.functional import tile
# 51
# 52
# 53
# 54
from mindspore.ops.function.random_func import normal_ext as normal
# 55
# 56
# 57
from mindspore.ops.functional import broadcast_to
# 58
from mindspore.ops.function.math_func import greater_equal
# 59
from mindspore.ops.functional import square
# 60
# 61
from mindspore.ops.functional import rsqrt
# 62
from mindspore.ops.functional import maximum
# 63
from mindspore.ops.functional import minimum
# 64
# 65
from mindspore.ops.functional import logical_and
# 66
from mindspore.ops.functional import logical_not
# 67
from mindspore.ops.functional import logical_or
# 68
# 69
from mindspore.ops.functional import less_equal, le
# 70
from mindspore.ops.functional import negative, neg
# 71
from mindspore.ops.functional import isfinite
# 72
# 73
from mindspore.ops.functional import ceil
# 74
from mindspore.ops.function.array_func import sort_ext as sort
# 75
from mindspore.ops.functional import less, lt
# 76
from mindspore.ops.functional import pow
# 77
# 78
from mindspore.ops.function import arange_ext as arange
# 79
# 80
# 81
from mindspore.ops.auto_generate import index_select_ext as index_select
# 82
# 83
from mindspore.ops.function.array_func import narrow_ext as narrow
# 84
# 85
from mindspore.mint import nn, optim
# 86
# 87
# 88
from mindspore.ops.function.array_func import chunk_ext as chunk
# 89
# 90
# 91
# 92
# 93
# 94
from mindspore.ops.function.math_func import tanh
# 95
# 96
# 97
# 98
# 99
# 100
# 122
# 176
from mindspore.ops.function.math_func import atan2_ext as atan2
from mindspore.ops.function.math_func import arctan2_ext as arctan2
# 208
from mindspore.ops.function.array_func import eye
from mindspore.ops.function.random_func import rand_ext as rand
from mindspore.ops.function.random_func import rand_like_ext as rand_like
# 210
from mindspore.ops.auto_generate import floor
# 231
from mindspore.ops.function.math_func import inverse_ext as inverse
# 285
from mindspore.ops.function.array_func import scatter_add_ext as scatter_add
[文档]def add(input, other, *, alpha=1):
r"""
Adds scaled other value to input Tensor.
.. math::
out_{i} = input_{i} + alpha \times other_{i}
Note:
- When the two inputs have different shapes,
they must be able to broadcast to a common shape.
- The two inputs and alpha comply with the implicit type conversion rules to make the data types
consistent.
Args:
input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
`number <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_ or
`bool_ <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_.
other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
a bool or a tensor whose data type is
`number <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_ or
`bool_ <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_.
Keyword Args:
alpha (number.Number): A scaling factor applied to `other`, default 1.
Returns:
Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
and the data type is the one with higher precision or higher digits among the two inputs and alpha.
Raises:
TypeError: If the type of `input`, `other`, or `alpha` is not one of the following: Tensor, number.Number, bool.
TypeError: If `alpha` is of type float but `input` and `other` are not of type float.
TypeError: If `alpha` is of type bool but `input` and `other` are not of type bool.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindspore import mint
>>> x = Tensor(1, mindspore.int32)
>>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
>>> alpha = 0.5
>>> output = mint.add(x, y, alpha=alpha)
>>> print(output)
[3. 3.5 4.]
>>> # the data type of x is int32, the data type of y is float32,
>>> # alpha is a float, and the output is the data format of higher precision float32.
>>> print(output.dtype)
Float32
"""
return ops.auto_generate.add_ext(input, other, alpha)
[文档]def any(input, dim=None, keepdim=False):
r"""
Reduces a dimension of `input` by the "logical OR" of all elements in the dimension, by default. And also can
reduce a dimension of `input` along the `dim`. Determine whether the dimensions of the output and input are the
same by controlling `keepdim`.
Note:
The `dim` with tensor type is only used for compatibility with older versions and is not recommended.
Args:
input (Tensor): Input Tensor, has the shape :math:`(N, *)` where :math:`*` means,
any number of additional dimensions.
dim (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce.
Suppose the rank of `input` is r, `dim` must be in the range [-rank(input), rank(input)).
Default: ``None`` , all dimensions are reduced.
keepdim (bool, optional): If ``True`` , keep these reduced dimensions and the length is 1.
If ``False`` , don't keep these dimensions. Default : ``False`` .
Returns:
Tensor, the dtype is bool.
- If `dim` is ``None`` , and `keepdim` is ``False`` ,
the output is a 0-D Tensor representing the "logical OR" of all elements in the input Tensor.
- If `dim` is int, such as 2, and `keepdim` is ``False`` ,
the shape of output is :math:`(input_1, input_3, ..., input_R)`.
- If `dim` is tuple(int), such as (2, 3), and `keepdim` is ``False`` ,
the shape of output is :math:`(input_1, input_4, ..., input_R)`.
- If `dim` is 1-D Tensor, such as [2, 3], and `keepdim` is ``False`` ,
the shape of output is :math:`(input_1, input_4, ..., input_R)`.
Raises:
TypeError: If `keepdim` is not a bool.
TypeError: If `input` is not a Tensor.
TypeError: If `dim` is not one of the following: int, tuple, list or Tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import numpy as np
>>> from mindspore import Tensor, mint
>>> x = Tensor(np.array([[True, False], [True, True]]))
>>> # case 1: Reduces a dimension by the "logical OR" of all elements in the dimension.
>>> output = mint.any(x, keepdim=True)
>>> print(output)
[[ True]]
>>> print(output.shape)
(1, 1)
>>> # case 2: Reduces a dimension along dim 0.
>>> output = mint.any(x, dim=0)
>>> print(output)
[ True True]
>>> # case 3: Reduces a dimension along dim 1.
>>> output = mint.any(x, dim=1)
>>> print(output)
[ True True]
"""
return ops.functional.any(input, dim, keepdim)
[文档]def all(input, dim=None, keepdim=False):
r"""
Reduces a dimension of `input` by the "logical AND" of all elements in the dimension, by default. And also can
reduce a dimension of `input` along the `dim`. Determine whether the dimensions of the output and input are the
same by controlling `keepdim`.
Note:
The `dim` with tensor type is only used for compatibility with older versions and is not recommended.
Args:
input (Tensor): Input Tensor, has the shape :math:`(N, *)` where :math:`*` means,
any number of additional dimensions.
dim (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce.
Suppose the rank of `input` is r, `dim` must be in the range [-rank(input), rank(input)).
Default: ``None`` , all dimensions are reduced.
keepdim (bool, optional): If ``True`` , keep these reduced dimensions and the length is 1.
If ``False`` , don't keep these dimensions. Default : ``False`` .
Returns:
Tensor, the dtype is bool.
- If `dim` is ``None`` , and `keepdim` is ``False`` ,
the output is a 0-D Tensor representing the "logical AND" of all elements in the input Tensor.
- If `dim` is int, such as 2, and `keepdim` is ``False`` ,
the shape of output is :math:`(input_1, input_3, ..., input_R)`.
- If `dim` is tuple(int), such as (2, 3), and `keepdim` is ``False`` ,
the shape of output is :math:`(input_1, input_4, ..., input_R)`.
- If `dim` is 1-D Tensor, such as [2, 3], and `keepdim` is ``False`` ,
the shape of output is :math:`(input_1, input_4, ..., input_R)`.
Raises:
TypeError: If `keepdim` is not a bool.
TypeError: If `input` is not a Tensor.
TypeError: If `dim` is not one of the following: int, tuple, list or Tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import numpy as np
>>> from mindspore import Tensor, mint
>>> x = Tensor(np.array([[True, False], [True, True]]))
>>> # case 1: Reduces a dimension by the "logicalAND" of all elements in the dimension.
>>> output = mint.all(x, keepdim=True)
>>> print(output)
[[False]]
>>> print(output.shape)
(1, 1)
>>> # case 2: Reduces a dimension along axis 0.
>>> output = mint.all(x, dim=0)
>>> print(output)
[ True False]
>>> # case 3: Reduces a dimension along axis 1.
>>> output = mint.all(x, dim=1)
>>> print(output)
[False True]
"""
return ops.function.math_func.all(input, dim, keepdim)
[文档]def cat(tensors, dim=0):
r"""
Connect input tensors along with the given dimension.
The input data is a tuple or a list of tensors. These tensors have the same rank :math:`R`.
Set the given dimension as :math:`m`, and :math:`0 \le m < R`. Set the number of input tensors as :math:`N`.
For the :math:`i`-th tensor :math:`t_i`, it has the shape of :math:`(x_1, x_2, ..., x_{mi}, ..., x_R)`.
:math:`x_{mi}` is the :math:`m`-th dimension of the :math:`t_i`. Then, the shape of the output tensor is
.. math::
(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)
Args:
tensors (Union[tuple, list]): A tuple or a list of input tensors.
Suppose there are two tensors in this tuple or list, namely t1 and t2.
To perform `concat` in the dimension 0 direction, except for the :math:`0`-th dimension,
all other dimensions should be equal, that is,
:math:`t1.shape[1] = t2.shape[1], t1.shape[2] = t2.shape[2], ..., t1.shape[R-1] = t2.shape[R-1]`,
where :math:`R` represents the rank of tensor.
dim (int): The specified dimension, whose value is in range :math:`[-R, R)`. Default: ``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`.
Raises:
TypeError: If `dim` is not an int.
ValueError: If `tensors` have different dimension of tensor.
ValueError: If `dim` not in range :math:`[-R, R)`.
ValueError: If tensor's shape in `tensors` except for `dim` are different.
ValueError: If `tensors` is an empty tuple or list.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore import mint
>>> input_x1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
>>> input_x2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
>>> output = mint.cat((input_x1, input_x2))
>>> print(output)
[[0. 1.]
[2. 1.]
[0. 1.]
[2. 1.]]
>>> output = mint.cat((input_x1, input_x2), 1)
>>> print(output)
[[0. 1. 0. 1.]
[2. 1. 2. 1.]]
"""
return ops.auto_generate.cat(tensors, dim)
[文档]def mean(input, dim=None, keepdim=False, *, dtype=None):
r"""
Reduces all dimension of a tensor by averaging all elements in the dimension, by default.
And reduce a dimension of `input` along the specified `dim`. `keepdim`
determines whether the dimensions of the output and input are the same.
Note:
The `dim` with tensor type is only used for compatibility with older versions and is not recommended.
Args:
input (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
:math:`(N, *)` where :math:`*` means, any number of additional dimensions.
dim (Union[int, tuple(int), list(int), Tensor]): The dimensions to reduce. Default: ``None`` ,
reduce all dimensions. Only constant value is allowed. Assume the rank of `input` is r,
and the value range is [-r,r).
keepdim (bool): If ``True`` , keep these reduced dimensions and the length is 1.
If ``False`` , don't keep these dimensions. Default: ``False`` .
Keyword Args:
dtype (:class:`mindspore.dtype`, optional): The desired data type of returned Tensor. Default: ``None`` .
Returns:
Tensor.
- If `dim` is ``None`` , and `keepdim` is ``False`` ,
the output is a 0-D tensor representing the product of all elements in the input tensor.
- If `dim` is int, set as 1, and `keepdim` is ``False`` ,
the shape of output is :math:`(input_0, input_2, ..., input_R)`.
- If `dim` is tuple(int) or list(int), set as (1, 2), and `keepdim` is ``False`` ,
the shape of output is :math:`(input_0, input_3, ..., input_R)`.
- If `dim` is 1-D Tensor, set as [1, 2], and `keepdim` is ``False`` ,
the shape of output is :math:`(input_0, input_3, ..., input_R)`.
Raises:
TypeError: If `input` is not a Tensor.
TypeError: If `dim` is not one of the following: int, tuple, list or Tensor.
TypeError: If `keepdim` is not a bool.
ValueError: If `dim` is out of range.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor, mint
>>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
>>> output = mint.mean(x, 1, keepdim=True)
>>> result = output.shape
>>> print(result)
(3, 1, 5, 6)
>>> # case 1: Reduces a dimension by averaging all elements in the dimension.
>>> x = Tensor(np.array([[[2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2]],
... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
... [[6, 6, 6, 6, 6, 6], [8, 8, 8, 8, 8, 8], [10, 10, 10, 10, 10, 10]]]),
... mindspore.float32)
>>> output = mint.mean(x)
>>> print(output)
5.0
>>> print(output.shape)
()
>>> # case 2: Reduces a dimension along the axis 0
>>> output = mint.mean(x, 0, True)
>>> print(output)
[[[4. 4. 4. 4. 4. 4.]
[5. 5. 5. 5. 5. 5.]
[6. 6. 6. 6. 6. 6.]]]
>>> # case 3: Reduces a dimension along the axis 1
>>> output = mint.mean(x, 1, True)
>>> print(output)
[[[2. 2. 2. 2. 2. 2.]]
[[5. 5. 5. 5. 5. 5.]]
[[8. 8. 8. 8. 8. 8.]]]
>>> # case 4: Reduces a dimension along the axis 2
>>> output = mint.mean(x, 2, True)
>>> print(output)
[[[ 2.]
[ 2.]
[ 2.]]
[[ 4.]
[ 5.]
[ 6.]]
[[ 6.]
[ 8.]
[10.]]]
"""
return ops.function.math_func.mean_ext(input, axis=dim, keep_dims=keepdim, dtype=dtype)
[文档]def prod(input, dim=None, keepdim=False, *, dtype=None):
r"""
Reduces a dimension of a tensor by multiplying all elements in the dimension, by default. And also can
reduce a dimension of `input` along the `dim`. Determine whether the dimensions of the output and input are the
same by controlling `keepdim`.
Args:
input (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
:math:`(N, *)` where :math:`*` means, any number of additional dimensions.
dim (int): The dimensions to reduce. Default: ``None`` , reduce all dimensions. Only constant value is allowed.
Assume the rank of `x` is r, and the value range is [-r,r).
keepdim (bool): If ``True`` , keep these reduced dimensions and the length is 1.
If ``False`` , don't keep these dimensions. Default: ``False`` .
Keyword Args:
dtype (:class:`mindspore.dtype`, optional): The desired data type of returned Tensor. Default: ``None`` .
Returns:
Tensor.
- If `dim` is ``None`` , and `keepdim` is ``False`` ,
the output is a 0-D tensor representing the product of all elements in the input tensor.
- If `dim` is int, set as 1, and `keepdim` is ``False`` ,
the shape of output is :math:`(input_0, input_2, ..., input_R)`.
Raises:
TypeError: If `input` is not a Tensor.
TypeError: If `dim` is not int.
TypeError: If `keepdim` is not a bool.
ValueError: If `dim` is out of range.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor, mint
>>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
>>> output = mint.prod(x, 1, keepdim=True)
>>> result = output.shape
>>> print(result)
(3, 1, 5, 6)
>>> # case 1: Reduces a dimension by multiplying all elements in the dimension.
>>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
... [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]), mindspore.float32)
>>> output = mint.prod(x)
>>> print(output)
2.2833798e+33
>>> print(output.shape)
()
>>> # case 2: Reduces a dimension along axis 0.
>>> output = mint.prod(x, 0, True)
>>> print(output)
[[[ 28. 28. 28. 28. 28. 28.]
[ 80. 80. 80. 80. 80. 80.]
[162. 162. 162. 162. 162. 162.]]]
>>> # case 3: Reduces a dimension along axis 1.
>>> output = mint.prod(x, 1, True)
>>> print(output)
[[[ 6. 6. 6. 6. 6. 6.]]
[[120. 120. 120. 120. 120. 120.]]
[[504. 504. 504. 504. 504. 504.]]]
>>> # case 4: Reduces a dimension along axis 2.
>>> output = mint.prod(x, 2, True)
>>> print(output)
[[[1.00000e+00]
[6.40000e+01]
[7.29000e+02]]
[[4.09600e+03]
[1.56250e+04]
[4.66560e+04]]
[[1.17649e+05]
[2.62144e+05]
[5.31441e+05]]]
"""
return ops.auto_generate.prod_ext(input, axis=dim, keep_dims=keepdim, dtype=dtype)
[文档]def ones(size, *, dtype=None):
r"""
Creates a tensor filled with value ones.
Creates a tensor with shape described by the first argument and fills it with value ones in type of the second
argument.
Args:
size (Union[tuple[int], list[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
tuple or Tensor containing positive integers are allowed. If it is a Tensor,
it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
Keyword Args:
dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
`mindspore.float32` will be used. Default: ``None`` .
Returns:
Tensor, whose dtype and size are defined by input.
Raises:
TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore
>>> from mindspore import mint
>>> output = mint.ones((2, 2), dtype=mindspore.float32)
>>> print(output)
[[1. 1.]
[1. 1.]]
"""
return ops.auto_generate.ones(size, dtype)
[文档]def permute(input, dims):
"""
Permutes the dimensions of the input tensor according to input `dims` .
Args:
input (Tensor): Input Tensor.
dims (tuple(int)): The order of the dimensions. Permute rearranges the `input` according
to the order of the `dims`.
Returns:
Tensor, has the same dimension as input tensor, with `axis` suitably permuted.
Raises:
ValueError: If `dims` is None.
ValueError: If the number of elements of `dims` is not equal to `input` ndim.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor, mint
>>> input_x = Tensor(np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), mindspore.float32)
>>> input_perm = (0, 2, 1)
>>> print(mint.permute(input_x, input_perm))
[[[ 1. 4.]
[ 2. 5.]
[ 3. 6.]]
[[ 7. 10.]
[ 8. 11.]
[ 9. 12.]]]
"""
return ops.functional.permute(input, dims)
[文档]def split(tensor, split_size_or_sections, dim=0):
"""
Splits the Tensor into chunks along the given dim.
Args:
tensor (Tensor): A Tensor to be divided.
split_size_or_sections (Union[int, tuple(int), list(int)]):
If `split_size_or_sections` is an int type, `tensor` will be split into equally sized chunks,
each chunk with size `split_size_or_sections`. Last chunk will be smaller than `split_size_or_sections`
if `tensor.shape[dim]` is not divisible by `split_size_or_sections`.
If `split_size_or_sections` is a list type, then `tensor` will be split into len(split_size_or_sections)
chunks with sizes `split_size_or_sections` along the given `dim`.
dim (int): The dim along which to split. Default: ``0`` .
Returns:
A tuple of sub-tensors.
Raises:
TypeError: If argument `tensor` is not Tensor.
TypeError: If argument `dim` is not int.
ValueError: If argument `dim` is out of range of :[-tensor.ndim, tensor.ndim).
TypeError: If each element in `split_size_or_sections` is not integer.
TypeError: If argument `split_size_or_sections` is not int, tuple(int) or list(int).
ValueError: The sum of `split_size_or_sections` is not equal to x.shape[dim].
Supported Platforms:
``Ascend``
Examples:
>>> import numpy as np
>>> from mindspore import ops, Tensor
>>> input_x = np.arange(9).astype("float32")
>>> output = ops.split(Tensor(input_x), 3)
>>> print(output)
(Tensor(shape=[3], dtype=Float32, value= [ 0.00000000e+00, 1.00000000e+00, 2.00000000e+00]),
Tensor(shape=[3], dtype=Float32, value= [ 3.00000000e+00, 4.00000000e+00, 5.00000000e+00]),
Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00, 7.00000000e+00, 8.00000000e+00]))
"""
return ops.function.array_func.split_ext(tensor, split_size_or_sections, dim)
[文档]def sqrt(input):
r"""
Returns sqrt of a tensor element-wise.
.. math::
out_{i} = \sqrt{input_{i}}
Args:
input (Tensor): The input tensor with a dtype of number.Number.
Returns:
Tensor, has the same shape as the `input`.
Raises:
TypeError: If `input` is not a Tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor, mint
>>> input = Tensor(np.array([1.0, 4.0, 9.0]), mindspore.float32)
>>> output = mint.sqrt(input)
>>> print(output)
[1. 2. 3.]
"""
return ops.auto_generate.sqrt(input)
[文档]def sub(input, other, *, alpha=1):
r"""
Subtracts scaled other value from input Tensor.
.. math::
out_{i} = input_{i} - alpha \times other_{i}
Note:
- When the two inputs have different shapes,
they must be able to broadcast to a common shape.
- The two inputs and alpha comply with the implicit type conversion rules to make the data types
consistent.
Args:
input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
`number <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_ or
`bool_ <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_.
other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
a bool or a tensor whose data type is
`number <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_ or
`bool_ <https://www.mindspore.cn/docs/en/r2.3.0/api_python/mindspore.html#mindspore.dtype>`_.
Keyword Args:
alpha (number.Number): A scaling factor applied to `other`, default 1.
Returns:
Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
and the data type is the one with higher precision or higher digits among the two inputs and alpha.
Raises:
TypeError: If the type of `input`, `other`, or `alpha` is not one of the following: Tensor, number.Number, bool.
TypeError: If `alpha` is of type float but `input` and `other` are not of type float.
TypeError: If `alpha` is of type bool but `input` and `other` are not of type bool.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindspore import mint
>>> x = Tensor(np.array([4, 5, 6]).astype(np.float32))
>>> y = Tensor(1, mindspore.int32)
>>> alpha = 0.5
>>> output = mint.sub(x, y, alpha=alpha)
>>> print(output)
[3.5 4.5 5.5]
>>> # the data type of x is float32, the data type of y is int32,
>>> # alpha is a float, and the output is the data format of higher precision float32.
>>> print(output.dtype)
Float32
"""
return ops.auto_generate.sub_ext(input, other, alpha)
[文档]def zeros(size, *, dtype=None):
"""
Creates a tensor filled with 0 with shape described by `size` and fills it with value 0 in type of `dtype`.
Args:
size (Union[tuple[int], list[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
tuple or Tensor containing positive integers are allowed. If it is a Tensor,
it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
Keyword Args:
dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
mindspore.float32 will be used. Default: ``None`` .
Returns:
Tensor, whose dtype and size are defined by input.
Raises:
TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore
>>> from mindspore import mint
>>> output = mint.zeros((2, 2), dtype=mindspore.float32)
>>> print(output)
[[0. 0.]
[0. 0.]]
"""
return ops.auto_generate.zeros(size, dtype)
__all__ = [
'full',
'ones_like',
'zeros_like',
'abs',
'erf',
'where',
'linspace',
'isclose',
# 1
'div',
'divide',
'topk',
# 2
'sin',
# 3
'clamp',
# 4
# 5
'cumsum',
# 6
'stack',
# 7
'zeros',
# 8
# 9
# 10
'ne',
# 11
# 12
# 13
"flip",
# 14
# 15
'flatten',
# 16
'matmul',
'bmm',
# 17
'mean',
# 18
'sum',
# 19
'log',
# 20
'prod',
# 21
'mul',
# 22
# 23
# 24
# 25
'greater',
'gt',
# 26
'eq',
# 27
'reciprocal',
# 28
'exp',
# 29
'sqrt',
# 30
'searchsorted',
# 31
# 32
'sub',
# 33
'split',
# 34
# 35
'erfinv',
# 36
# 37
'nonzero',
# 38
# 39
# 40
'any',
# 41
'add',
# 42
'argmax',
# 43
'cat',
# 44
'cos',
# 45
# 46
# 47
'max',
# 48
'min',
# 49
# 50
'tile',
# 51
'permute',
# 52
# 53
# 54
'normal',
# 55
# 56
# 57
'broadcast_to',
# 58
'greater_equal',
# 59
'square',
# 60
'all',
# 61
'rsqrt',
# 62
'maximum',
# 63
'minimum',
# 64
# 65
'logical_and',
# 66
'logical_not',
# 67
'logical_or',
# 68
# 69
'less_equal',
'le',
# 70
'negative',
'neg',
# 71
'isfinite',
# 72
# 73
'ceil',
# 74
'sort',
# 75
'less',
'lt',
# 76
'pow',
# 77
# 78
'arange',
# 79
# 80
# 81
'index_select',
# 82
# 83
'narrow',
# 84
# 85
# 86
# 87
# 88
'chunk',
# 89
# 90
# 91
# 92
# 93
# 94
'tanh',
# 95
# 96
# 97
# 98
# 99
# 100
# 176
'atan2',
'arctan2',
# 208
'eye',
'rand',
'rand_like',
# 210
'floor',
# 231
'inverse',
# 285
'scatter_add',
# 304
# 305
'triu',
]
__all__.extend(array_func.__all__)
__all__.extend(math_func.__all__)
__all__.extend(nn_func.__all__)
__all__.extend(functional.__all__)
__all__.extend(nn.__all__)
__all__.extend(optim.__all__)
__all__.extend(linalg.__all__)