# Copyright 2020-2021 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 operations, the function docs are adapted from Numpy API."""
from __future__ import absolute_import
import operator
from mindspore.common import dtype as mstype
from mindspore.common import Tensor, mutable
from mindspore.ops import operations as P
from mindspore.ops import functional as F
from mindspore.ops.primitive import constexpr, _primexpr
from mindspore.nn import Cell
from mindspore import ops
from mindspore.numpy.utils import _convert_list_tensor_to_tuple_tensor, _expand, _broadcast_to_shape, \
_check_input_tensor, _broadcast_to, _to_tensor, _callable
from mindspore.numpy.utils_const import _check_axes_range, _check_start_normalize, \
_raise_type_error, _raise_value_error, _infer_out_shape, _empty, _promote, \
_check_same_type, _check_axis_valid, _add_unit_axes, _broadcast_tuples, \
_check_is_float, _check_axis_in_range, _check_axis_type, _canonicalize_axis, \
_list_comprehensions, _check_element_int, _is_shape_empty, _type_convert, \
_tuple_slice, _expanded_shape, _seq_prod, _tuple_setitem, _iota, \
_raise_unimplemented_error, _cumprod, _get_device, _check_is_int
# According to official numpy reference, the dimension of a numpy array must be less
# than 32
MAX_NUMPY_DIMS = 32
[docs]def expand_dims(a, axis):
"""
Expands the shape of a tensor.
Inserts a new axis that will appear at the axis position in the expanded tensor shape.
Args:
a (Tensor): Input tensor array.
axis (Union[int, list(int), tuple(int)]): Position in the expanded axes where
the new axis is placed,
Returns:
Tensor, with the number of dimensions increased at specified axis.
Raises:
TypeError: If input arguments have types not specified above.
ValueError: If axis exceeds a.ndim.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.ones((2,2))
>>> x = np.expand_dims(x,0)
>>> print(x.shape)
(1, 2, 2)
"""
_check_input_tensor(a)
if not isinstance(axis, (int, tuple, list)):
_raise_type_error("axis must be tuple, list or int, but got ", axis)
if isinstance(axis, int):
return F.expand_dims(a, axis)
ndim = a.ndim + len(axis)
axis = _canonicalize_axis(axis, ndim)
for ax in axis:
a = F.expand_dims(a, ax)
return a
[docs]def squeeze(a, axis=None):
"""
Removes single-dimensional entries from the shape of a tensor.
Args:
a (Tensor): Input tensor array.
axis (Union[None, int, list(int), tuple(list)], optional): The axis(axes) to squeeze,
default: ``None`` .
Returns:
Tensor, with all or a subset of the dimensions of length :math:`1` removed.
Raises:
TypeError: If input arguments have types not specified above.
ValueError: If specified axis has shape entry :math:`> 1`.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.ones((1,2,2,1))
>>> x = np.squeeze(x)
>>> print(x.shape)
(2, 2)
"""
_check_input_tensor(a)
return a.squeeze(axis)
[docs]def transpose(a, axes=None):
"""
Reverses or permutes the axes of a tensor; returns the modified tensor.
Args:
a (Tensor): a tensor to be transposed
axes (Union[None, tuple, list], optional): the axes order, if `axes` is `None`, transpose
the entire tensor. Default: ``None`` .
Returns:
Tensor, the transposed tensor array.
Raises:
TypeError: If input arguments have types not specified above.
ValueError: If the number of `axes` is not equal to a.ndim.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.ones((1,2,3))
>>> x = np.transpose(x)
>>> print(x.shape)
(3, 2, 1)
"""
_check_input_tensor(a)
return a.transpose(axes)
[docs]def rollaxis(x, axis, start=0):
"""
Rolls the specified axis backwards, until it lies in the given position.
The positions of the other axes do not change relative to one another.
Args:
x (Tensor): A Tensor to be transposed.
axis (int): The axis to be rolled.
start (int): Default: ``0`` .
If :math:`start <= axis`, the axis is rolled back until it lies in this position (`start`).
If :math:`start > axis`: the axis is rolled until it lies before this position (`start`).
If :math:`start < 0`, the start will be normalized as a non-negative number (more details
can be seen in the source code.)
.. table
+===========+=================+
|start |Normalized start |
+===========+=================+
|-(x.ndim+1)| raise ValueError|
+-----------+-----------------+
|-x.ndim |0 |
+-----------+-----------------+
|... |... |
+-----------+-----------------+
|-1 |x.ndim-1 |
+-----------+-----------------+
|... |... |
+-----------+-----------------+
|x.ndim |x.ndim |
+-----------+-----------------+
|x.ndim+1 |raise ValueError |
+===========+=================+
..
Returns:
Transposed Tensor. Has the same data type as the original tensor `x`.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If `axis` or `start` is not integer, or `x` is not tensor.
ValueError: If `axis` is not in the range of :math:`[-ndim, ndim-1]` or
`start` is not in the range of :math:`[-ndim, ndim]`.
Examples:
>>> import mindspore.numpy as np
>>> x = np.ones((2,3,4))
>>> output = np.rollaxis(x, 0, 2)
>>> print(output.shape)
(3, 2, 4)
"""
_check_input_tensor(x)
if not isinstance(axis, int):
_raise_type_error("integer argument expected, but got ", axis)
if not isinstance(start, int):
_raise_type_error("integer argument expected, but got ", start)
shape = F.shape(x)
ndim = F.tuple_len(shape)
axis = _check_axes_range(axis, ndim)
start = _check_start_normalize(start, ndim)
if start - axis >= 0 and start - axis <= 1:
return x
perm = F.make_range(0, ndim)
new_perm = None
if start < axis:
if axis + 1 < ndim:
new_perm = perm[0:start] + perm[axis:axis + 1] + \
perm[start:axis] + perm[axis + 1:]
else:
new_perm = perm[0:start] + perm[axis:axis + 1] + perm[start:axis]
if start > axis:
if start < ndim:
new_perm = perm[0:axis] + perm[axis + 1:start] + \
perm[axis:axis + 1] + perm[start:]
else:
new_perm = perm[0:axis] + perm[axis + 1:start] + \
perm[axis:axis + 1]
return F.transpose(x, new_perm)
[docs]def swapaxes(x, axis1, axis2):
"""
Interchanges two axes of a tensor.
Args:
x (Tensor): A tensor to be transposed.
axis1 (int): First axis.
axis2 (int): Second axis.
Returns:
Transposed tensor, has the same data type as the original tensor `x`.
Raises:
TypeError: If `axis1` or `axis2` is not integer, or `x` is not tensor.
ValueError: If `axis1` or `axis2` is not in the range of :math:`[-ndim, ndim-1]`.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.ones((2,3,4))
>>> output = np.swapaxes(x, 0, 2)
>>> print(output.shape)
(4,3,2)
"""
_check_input_tensor(x)
return x.swapaxes(axis1, axis2)
[docs]def reshape(x, new_shape):
"""
Reshapes a tensor without changing its data.
Args:
x (Tensor): A tensor to be reshaped.
new_shape (Union[int, list(int), tuple(int)]): The new shape should be
compatible with the original shape. If the tuple has only one element,
the result will be a 1-D tensor of that length. One shape dimension
can be :math:`-1`. In this case, the value is inferred from the length of
the tensor and remaining dimensions.
Returns:
Reshaped Tensor. Has the same data type as the original tensor `x`.
Raises:
TypeError: If new_shape is not integer, list or tuple, or `x` is not tensor.
ValueError: If new_shape is not compatible with the original shape.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.asarray([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]])
>>> output = np.reshape(x, (3, 2))
>>> print(output)
[[-0.1 0.3]
[ 3.6 0.4]
[ 0.5 -3.2]]
>>> output = np.reshape(x, (3, -1))
>>> print(output)
[[-0.1 0.3]
[ 3.6 0.4]
[ 0.5 -3.2]]
>>> output = np.reshape(x, (6, ))
>>> print(output)
[-0.1 0.3 3.6 0.4 0.5 -3.2]
"""
_check_input_tensor(x)
return x.reshape(new_shape)
[docs]def ravel(x):
"""
Returns a contiguous flattened tensor.
A 1-D tensor, containing the elements of the input, is returned.
Args:
x (Tensor): A tensor to be flattened.
Returns:
Flattened tensor, has the same data type as the original tensor `x`.
Raises:
TypeError: If `x` is not tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.ones((2,3,4))
>>> output = np.ravel(x)
>>> print(output.shape)
(24,)
"""
_check_input_tensor(x)
return x.ravel()
@_primexpr
def _move_axes_for_concatenate(arr_shape, axis):
"""
Moves axis 0 to the desiganated position, while keeps other axes' relative
positions unchanged, only used if a single tensor is concatenated.
"""
original_axes = tuple(range(len(arr_shape)))
new_axes = original_axes[1:axis + 1] + (0,) + original_axes[axis + 1:]
new_shape = arr_shape[1:axis + 1] + (arr_shape[0] * arr_shape[axis + 1],) + \
arr_shape[axis + 2:]
return new_axes, new_shape
def _promote_type_for_concatenate(tuple_of_tensors):
"""
Checks dtype for all tensors in the tuple. If dtypes are not the same, promote
them to the `highest` dtype in the tuple, so that they are ready for the concat
operator.
Args:
tuple_of_tensors(tuple(tensor)): A tuple of tensors
Returns:
tuple of tensors, with each tensor promoted to ths same dtype.
"""
need_cast = False
final_type = tuple_of_tensors[0].dtype
for tensor in tuple_of_tensors:
if not _check_same_type(final_type, tensor.dtype):
need_cast = True
final_type = _promote(final_type, tensor.dtype)
if not need_cast:
return tuple_of_tensors
tuple_of_casted_tensors = ()
for tensor in tuple_of_tensors:
tuple_of_casted_tensors += (tensor.astype(final_type, False),)
return tuple_of_casted_tensors
[docs]def concatenate(arrays, axis=0):
"""
Joins a sequence of tensors along an existing axis.
Note:
To match Numpy behaviour, :math:`axis >= 32` will not cause value error, the
`axis` will be treated as ``None`` instead.
Args:
arrays (Union[Tensor, tuple(Tensor), list(Tensor)]): a tensor or a list
of tensors to be concatenated.
axis (Union[None, int], optional): The axis along which the tensors will be joined,
if `axis` is ``None``, tensors are flattened before use. Default: ``0`` .
Returns:
A tensor concatenated from a tensor or a list of tensors.
Raises:
TypeError: If input arguments have types not specified above.
ValueError: If `axis` is not in the range of :math:`[-ndim, ndim-1]`, and less than 32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x1 = np.ones((1,2,3))
>>> x2 = np.ones((1,2,1))
>>> x = np.concatenate((x1, x2), axis=-1)
>>> print(x.shape)
(1, 2, 4)
"""
if arrays is None:
_raise_type_error('expect Union[Tensor, tuple(Tensor), list(Tensor)], but got None')
if isinstance(arrays, Tensor):
# if only one tensor is provided, it is treated as a tuple along the
# first dimension. For example, a tensor of shape (3,4,5) will be treated
# as: tuple(tensor_1(4,5), tensor_2(4,5), tensor_3(4,5))
if axis is None or axis >= MAX_NUMPY_DIMS:
return ravel(arrays)
arr_shape = F.shape(arrays)
_check_axes_range((axis,), len(arr_shape))
# move axis 0 to the disiganated position, while keep other axes' relative
# positions unchanged
new_axes, new_shape = _move_axes_for_concatenate(arr_shape, axis)
arrays = transpose(arrays, new_axes)
arrays = reshape(arrays, new_shape)
return arrays
flattened_arrays = ()
if axis is None or axis >= MAX_NUMPY_DIMS:
for arr in arrays:
flattened_arrays += (ravel(arr),)
axis = -1
flattened_arrays = _promote_type_for_concatenate(flattened_arrays)
return P.Concat(axis)(flattened_arrays)
# convert a list of tensor to a tuple of tensor
arrays = _convert_list_tensor_to_tuple_tensor(arrays)
arr_shape = F.shape(arrays[0])
_check_axes_range((axis,), len(arr_shape))
# if only one tensor in the tuple/list, return the tensor itself
if len(arrays) == 1:
return arrays[0]
arrays = _promote_type_for_concatenate(arrays)
return P.Concat(axis)(arrays)
[docs]def append(arr, values, axis=None):
"""
Appends values to the end of a tensor.
Args:
arr (Tensor): Values are appended to a copy of this tensor.
values (Tensor): These values are appended to a copy of `arr`. It must be of
the correct shape (the same shape as `arr`, excluding `axis`). If `axis` is
not specified, `values` can be any shape and will be flattened before use.
axis (int, optional): The `axis` along which values are appended. If `axis` is not
given, both `arr` and `values` are flattened before use, default is ``None``.
Returns:
Tensor, a copy of tensor with values appended to axis.
Raises:
TypeError: If input arguments have types not specified above.
ValueError: If specified axis exceeds `arr.ndim`.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> a = np.ones((2, 3))
>>> b = np.ones((2, 1))
>>> print(np.append(a, b, axis=1).shape)
(2, 4)
"""
_check_input_tensor(arr)
_check_input_tensor(values)
if axis is None:
arr = arr.ravel()
values = values.ravel()
else:
_check_axis_in_range(axis, arr.ndim)
if F.rank(arr) != F.rank(values):
_raise_value_error("all tensors must have same number of dimensions")
return concatenate((arr, values), axis)
[docs]def column_stack(tup):
"""
Stacks 1-D tensors as columns into a 2-D tensor. 2-D tensors are stacked as-is,
like np.hstack.
Args:
tup (Union[Tensor, tuple, list]): A sequence of 1-D or 2-D tensors. All
of them must have the same shape except the axis to be concatenated.
Returns:
2-D Tensor, formed by stacking the given tensors.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If `tup` is not Tensor, list or tuple.
ValueError: If `tup` is empty.
Examples:
>>> import mindspore.numpy as np
>>> x1 = np.array([1, 2, 3]).astype('int32')
>>> x2 = np.array([4, 5, 6]).astype('int32')
>>> output = np.column_stack((x1, x2))
>>> print(output)
[[1 4]
[2 5]
[3 6]]
"""
if isinstance(tup, Tensor):
return tup
if not isinstance(tup, (list, tuple)):
_raise_type_error("Tensor or, list or tuple of tensors are required, but got ", tup)
trans_tup = ()
for tensor in tup:
if tensor.ndim < 1:
tensor = F.expand_dims(tensor, 0)
if tensor.ndim == 1:
tensor = F.expand_dims(tensor, 1)
trans_tup += (tensor,)
if not trans_tup:
_raise_value_error("Need at least one tensor to concatenate.")
return P.Concat(1)(trans_tup)
[docs]def vstack(tup):
"""
Stacks tensors in sequence vertically.
This is equivalent to concatenation along the first axis. 1-D tensors should firstly be reshaped to `(1, N)`,
and then be concatenated along the first axis.
Args:
tup (Union[Tensor, tuple, list]): A sequence of 1-D or 2-D tensors. The tensors must have the same shape
along all but the first axis. 1-D tensors must have the same shape.
Returns:
Stacked Tensor, formed by stacking the given tensors.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If `tup` is not Tensor, list or tuple.
ValueError: If `tup` is empty.
Examples:
>>> import mindspore.numpy as np
>>> x1 = np.array([1, 2, 3]).astype('int32')
>>> x2 = np.array([4, 5, 6]).astype('int32')
>>> output = np.vstack((x1, x2))
>>> print(output)
[[1 2 3]
[4 5 6]]
"""
if isinstance(tup, Tensor):
return tup
if not isinstance(tup, (list, tuple)):
_raise_type_error("Tensor or, list or tuple of tensors are required, but got", tup)
trans_tup = ()
for tensor in tup:
if tensor.ndim <= 1:
tensor = _expand(tensor, 2, 0)
trans_tup += (tensor,)
if not trans_tup:
_raise_value_error("Need at least one tensor to concatenate.")
return P.Concat(0)(trans_tup)
[docs]def hstack(tup):
"""
Stacks tensors in sequence horizontally.
This is equivalent to concatenation along the second axis, except for 1-D tensors
where it concatenates along the first axis.
Args:
tup (Union[Tensor, tuple, list]): A sequence of 1-D or 2-D tensors. The
tensors must have the same shape along all but the second axis, except
1-D tensors which can be any length.
Returns:
Stacked Tensor, formed by stacking the given tensors.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If `tup` is not Tensor, list or tuple.
ValueError: If `tup` is empty.
Examples:
>>> import mindspore.numpy as np
>>> x1 = np.array([1, 2, 3]).astype('float32')
>>> x2 = np.array([4, 5, 6]).astype('float32')
>>> output = np.hstack((x1, x2))
>>> print(output)
[1. 2. 3. 4. 5. 6.]
"""
if isinstance(tup, Tensor):
return tup
if not isinstance(tup, (list, tuple)):
_raise_type_error("Tensor or, list or tuple of tensors are required, but got", tup)
tuple_of_tensor = ()
for tensor in tup:
if tensor.ndim < 1:
tensor = F.expand_dims(tensor, 0)
tuple_of_tensor += (tensor,)
if not tuple_of_tensor:
_raise_value_error("Need at least one tensor to concatenate.")
if tuple_of_tensor[0].ndim <= 1:
return P.Concat(0)(tuple_of_tensor)
return P.Concat(1)(tuple_of_tensor)
[docs]def dstack(tup):
"""
Stacks tensors in sequence depth wise (along the third axis).
This is equivalent to concatenation along the third axis. 1-D tensors :math:`(N,)` should be
reshaped to :math:`(1,N,1)`.
2-D tensors :math:`(M,N)` should be reshaped to :math:`(M,N,1)` before concatenation.
Args:
tup (Union[Tensor, tuple, list]): A sequence of tensors. The tensors must have the same shape along all but
the third axis. 1-D or 2-D tensors must have the same shape.
Returns:
Stacked Tensor, formed by stacking the given tensors.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If `tup` is not Tensor, list or tuple.
ValueError: If `tup` is empty.
Examples:
>>> import mindspore.numpy as np
>>> x1 = np.array([1, 2, 3]).astype('float32')
>>> x2 = np.array([4, 5, 6]).astype('float32')
>>> output = np.dstack((x1, x2))
>>> print(output)
[[[1. 4.]
[2. 5.]
[3. 6.]]]
"""
if isinstance(tup, Tensor):
return tup
if not isinstance(tup, (list, tuple)):
_raise_type_error("Tensor or list or tuple of tensors are required, but got", tup)
trans_tup = ()
for tensor in tup:
if tensor.ndim <= 1:
tensor = _expand(tensor, 2, 0)
if tensor.ndim == 2:
tensor = F.expand_dims(tensor, 2)
trans_tup += (tensor,)
if not trans_tup:
_raise_value_error("Need at least one tensor to concatenate.")
return P.Concat(2)(trans_tup)
[docs]def where(condition, x=None, y=None):
"""
Returns elements chosen from `x` or `y` depending on `condition`.
Note:
As nonzero is not supported, both `x` and `y` must be provided Tensor
input.
Args:
condition (Tensor): where True, yield `x`, otherwise yield `y`.
x (Tensor, optional): Values from which to choose. Default: ``None`` .
y (Tensor, optional): Values from which to choose. `x`, `y` and `condition` need
to be broadcastable to some shape. Default: ``None`` .
Returns:
Tensor or scalar, with elements from `x` where `condition` is True, and
elements from `y` elsewhere.
Raises:
ValueError: If operands cannot be broadcast.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> condition = np.full((1, 1, 2), [False, True])
>>> x = np.full((1, 3, 2), 5)
>>> y = np.full((2, 1, 1), 7)
>>> output = np.where(condition, x, y)
>>> print(output)
[[[7 5]
[7 5]
[7 5]]
[[7 5]
[7 5]
[7 5]]]
"""
condition, x, y = _to_tensor(condition, x, y)
# type promotes input tensors
dtype1 = F.dtype(x)
dtype2 = F.dtype(y)
dtype = _promote(dtype1, dtype2)
if not _check_same_type(dtype1, dtype):
x = F.cast(x, dtype)
if not _check_same_type(dtype2, dtype):
y = F.cast(y, dtype)
is_bool = _check_same_type(dtype1, mstype.bool_) and _check_same_type(dtype2, mstype.bool_)
if is_bool:
# select does not support bool type for x or y
x = F.cast(x, mstype.float32)
y = F.cast(y, mstype.float32)
dynamic = F.is_sequence_value_unknown(F.shape(condition)) or F.is_sequence_value_unknown(F.shape(x))\
or F.is_sequence_value_unknown(F.shape(y))
# As select op currently does not support broadcast, broadcasts input tensors
if not dynamic:
shape_out = _infer_out_shape(F.shape(condition),
F.shape(x), F.shape(y))
condition = _broadcast_to_shape(condition, shape_out)
x = _broadcast_to_shape(x, shape_out)
y = _broadcast_to_shape(y, shape_out)
else:
# Get the broadcast shape through broadcast calculation
add_x_y = x + y
add_out = condition + F.cast(add_x_y, condition.dtype)
shape_out = P.Shape()(add_out)
condition = ops.broadcast_to(condition, shape_out)
x = ops.broadcast_to(x, shape_out)
y = ops.broadcast_to(y, shape_out)
if not _check_same_type(F.dtype(condition), mstype.bool_):
condition = F.cast(condition, mstype.bool_)
res = F.select(condition, x, y)
if is_bool:
res = F.cast(res, mstype.bool_)
return res
def _atleast_xd(ndim, arys):
"""Returns arys with at least ndim."""
_check_input_tensor(*arys)
res = []
for arr in arys:
arr = _expand(arr, ndim)
res.append(arr)
if len(res) == 1:
return res[0]
return res
[docs]def atleast_1d(*arys):
"""
Converts inputs to arrays with at least one dimension.
Scalar inputs are converted to 1-dimensional arrays, whilst
higher-dimensional inputs are preserved.
Note:
In graph mode, returns a tuple of tensor instead of a list of
tensors.
Args:
*arys (Tensor): one or more input tensors.
Returns:
Tensor, or list of tensors, each with ``a.ndim >= 1``.
Raises:
TypeError: If the input is not a tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> a = np.ones((2, 3))
>>> b = np.ones(())
>>> c = np.ones(5)
>>> output = np.atleast_1d(a, b, c)
>>> print(output)
[Tensor(shape=[2, 3], dtype=Float32, value=
[[1.00000000e+00, 1.00000000e+00, 1.00000000e+00],
[1.00000000e+00, 1.00000000e+00, 1.00000000e+00]]),
Tensor(shape=[1], dtype=Float32, value= [1.00000000e+00]),
Tensor(shape=[5], dtype=Float32,
value= [1.00000000e+00, 1.00000000e+00, 1.00000000e+00,
1.00000000e+00, 1.00000000e+00])]
"""
return _atleast_xd(1, arys)
[docs]def atleast_2d(*arys):
"""
Reshapes inputs as arrays with at least two dimensions.
Note:
In graph mode, returns a tuple of tensor instead of a list of
tensors.
Args:
*arys (Tensor): one or more input tensors.
Returns:
Tensor, or list of tensors, each with ``a.ndim >= 2``.
Raises:
TypeError: If the input is not a tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> a = np.ones((2, 3))
>>> b = np.ones(())
>>> c = np.ones(5)
>>> output = np.atleast_2d(a, b, c)
>>> print(output)
[Tensor(shape=[2, 3], dtype=Float32, value=
[[1.00000000e+00, 1.00000000e+00, 1.00000000e+00],
[1.00000000e+00, 1.00000000e+00, 1.00000000e+00]]),
Tensor(shape=[1, 1], dtype=Float32, value= [[1.00000000e+00]]),
Tensor(shape=[1, 5], dtype=Float32,
value= [[1.00000000e+00, 1.00000000e+00, 1.00000000e+00,
1.00000000e+00, 1.00000000e+00]])]
"""
return _atleast_xd(2, arys)
[docs]def atleast_3d(*arys):
"""
Reshapes inputs as arrays with at least three dimensions.
Note:
In graph mode, returns a tuple of tensor instead of a list of
tensors.
Args:
*arys (Tensor): one or more input tensors.
Returns:
Tensor, or list of tensors, each with ``a.ndim >= 3``. For example,
a 1-D array of shape `(N,)` becomes a tensor of shape `(1, N, 1)`, and
a 2-D array of shape `(M, N)` becomes a tensor of shape `(M, N, 1)`.
Raises:
TypeError: If the input is not a tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> a = np.ones((2, 3))
>>> b = np.ones(())
>>> c = np.ones(5)
>>> output = np.atleast_3d(a, b, c)
>>> print(output)
[Tensor(shape=[2, 3, 1], dtype=Float32, value=
[[[1.00000000e+00], [1.00000000e+00], [1.00000000e+00]],
[[1.00000000e+00], [1.00000000e+00], [1.00000000e+00]]]),
Tensor(shape=[1, 1, 1], dtype=Float32, value= [[[1.00000000e+00]]]),
Tensor(shape=[1, 5, 1], dtype=Float32,
value= [[[1.00000000e+00], [1.00000000e+00], [1.00000000e+00],
[1.00000000e+00], [1.00000000e+00]]])]
"""
res = []
for arr in arys:
ndim = F.rank(arr)
if ndim == 0:
arr = F.reshape(arr, (1, 1, 1))
elif ndim == 1:
arr = F.reshape(arr, (1, F.size(arr), 1))
elif ndim == 2:
arr = F.reshape(arr, F.shape(arr) + (1,))
res.append(arr)
if len(res) == 1:
return res[0]
return res
[docs]def stack(arrays, axis=0):
"""
Joins a sequence of arrays along a new axis.
The `axis` parameter specifies the index of the new axis in the
dimensions of the result. For example, if ``axis=0`` it will be the
first dimension and if ``axis=-1`` it will be the last dimension.
Note:
Numpy argument out is not supported.
Args:
arrays (sequence of Tensor): Each array must have the same shape.
axis (int, optional): The axis in the result array along which the
input arrays are stacked. Default: ``0`` .
Returns:
Tensor, The stacked array has one more dimension than the input
arrays.
Raises:
ValueError: If input is not Tensor, tuple, or list.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> arrays = [np.ones((3, 4)) for _ in range(10)]
>>> output = np.stack(arrays, axis=0)
>>> print(output.shape)
(10, 3, 4)
>>> output = np.stack(arrays, axis=1)
>>> print(output.shape)
(3, 10, 4)
>>> output = np.stack(arrays, axis=2)
>>> print(output.shape)
(3, 4, 10)
"""
if isinstance(arrays, Tensor):
shape = F.shape(arrays)
ndim = F.rank(arrays)
axis = axis % ndim
axes = F.make_range(ndim)
perm = axes[1:axis + 1] + (0,) + axes[axis + 1:]
if _is_shape_empty(shape):
return _empty(mstype.float32, shape[1:axis + 1] + (shape[0],) + shape[axis + 1:])
return transpose(arrays, perm)
if isinstance(arrays, (list, tuple)):
shape = (len(arrays),) + F.shape(arrays[0])
ndim = len(shape)
axis = axis % ndim
if _is_shape_empty(shape):
return _empty(mstype.float32, shape[1:axis + 1] + (shape[0],) + shape[axis + 1:])
seq = ()
for arr in arrays:
seq += (F.expand_dims(arr, axis),)
return concatenate(seq, axis)
return _raise_value_error('input arrays must be Tensor, tuple, or list')
class UniqueNet(Cell):
"""The operation is wrapped inside a model. """
def __init__(self):
super(UniqueNet, self).__init__()
self.unique = P.Unique()
def construct(self, x):
return self.unique(x)
[docs]def unique(x, return_inverse=False):
"""
Finds the unique elements of a tensor. The input tensor will be flattened first
when it has more than one dimension.
Note:
Numpy arguments `axis`, `return_index` and `return_counts` are not supported.
On CPU, this operator must be executed in graph mode.
Args:
x (Tensor): The input tensor to be processed.
return_inverse (bool, optional): If `True`, also return the indices of the unique tensor.
Default: ``False`` .
Returns:
Tensor or tuple of Tensors.
If `return_inverse` is `False`, return the unique tensor, otherwise return tuple of tensors.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If `x` is not tensor.
Examples:
>>> import mindspore.numpy as np
>>> import mindspore as ms
>>> ms.set_context(mode=ms.GRAPH_MODE)
>>> input_x = np.asarray([1, 2, 2, 2, 3, 4, 5]).astype('int32')
>>> output_x = np.unique(input_x)
>>> print(output_x)
[1 2 3 4 5]
>>> output_x = np.unique(input_x, return_inverse=True)
>>> print(output_x)
(Tensor(shape=[5], dtype=Int32, value= [ 1, 2, 3, 4, 5]), Tensor(shape=[7], dtype=Int32,
value= [0, 1, 1, 1, 2, 3, 4]))
"""
_check_input_tensor(x)
if F.tuple_len(F.shape(x)) > 1:
x = ravel(x)
uniq = UniqueNet()
res = uniq(x)
if not return_inverse:
return res[0]
return res
def roll_along_axis(a, shift, axis):
"""
Rolls a tensor along a given axis. This is a helper function of np.roll.
Args:
a (Tensor): Input tensor.
shift (int): The number of places the tensor is shifted.
axis (int): The designated axis for shifting.
Returns:
Shifted tensor.
"""
_check_axis_in_range(axis, a.ndim)
_check_element_int((shift, axis))
if axis < 0:
axis += a.ndim
shift = -(shift % a.shape[axis])
# if shift is 0, we do not need to roll at all
if shift == 0:
return a
begin1 = ()
begin2 = ()
end1 = ()
end2 = ()
stride = _list_comprehensions(a.ndim, 1, True)
for i in F.make_range(a.ndim):
if i != axis:
begin1 += (0,)
end1 += (a.shape[i],)
begin2 += (0,)
end2 += (a.shape[i],)
else:
begin1 += (shift,)
end1 += (a.shape[i],)
begin2 += (0,)
end2 += (shift,)
return append(F.strided_slice(a, begin1, end1, stride),
F.strided_slice(a, begin2, end2, stride), axis=axis)
[docs]def roll(a, shift, axis=None):
"""
Rolls a tensor along given axes.
Elements that rolls beyond the last position are re-introduced at the first.
Args:
a (Tensor): Input tensor.
shift (Union[int, tuple(int)]): The number of places by which elements are
shifted. If a tuple, then axis must be a tuple of the same size, and
each of the given axes is shifted by the corresponding number. If shift
is an int while axis is a tuple of integers, then the same value is used
for all given axes.
axis (Union[int, tuple(int)], optional): Axis or axes along which elements
are shifted. By default, the array is flattened before shifting, after
which the original shape is restored. Default: ``None`` .
Returns:
Tensor, with the same shape as a.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If input arguments have types not specified above.
ValueError: If axis exceeds `a.ndim`, or `shift` and `axis` cannot broadcast.
Examples:
>>> import mindspore.numpy as np
>>> a = np.reshape(np.arange(12), (3, 4))
>>> print(np.roll(a, [2,-3], [0,-1]))
[[ 7 4 5 6]
[11 8 9 10]
[ 3 0 1 2]]
"""
_check_input_tensor(a)
original_shape = a.shape
original_dtype = a.dtype
restore_shape = False
# F.strided_slice only supports float on cpu, this will change once more supports
# are added.
if not _check_is_float(original_dtype):
if not original_dtype in (mstype.complex64, mstype.complex128):
a = a.astype(mstype.float32)
if axis is None:
restore_shape = True
axis = 0
a = a.ravel()
# Broadcast shift and axis to the same length
shift, axis = _broadcast_tuples(shift, axis)
for shift_each, axis_each in zip(shift, axis):
a = roll_along_axis(a, shift_each, axis_each)
if restore_shape:
a = a.reshape(original_shape)
if not _check_is_float(original_dtype):
if not original_dtype in (mstype.complex64, mstype.complex128):
a = a.astype(original_dtype)
return a
@_primexpr
def _get_moved_perm(ndim, source, destination):
"""
Helper function for moveaxis, returns permutation after moving axes
from source to destination.
"""
dest_sorted_idx = [i for i, _ in sorted(enumerate(destination), key=operator.itemgetter(1))]
axes_orig = mutable([], True)
for i in range(ndim):
if i not in source:
axes_orig = axes_orig + [i]
k = 0
m = 0
perm = []
for i in dest_sorted_idx:
# inserts an axis that has been moved, denoted by n, and axes that remain
# in their original position, indexed from k to k + n - m, into index m in
# the list of permuted axes
n = destination[i]
j = k + n - m
perm += axes_orig[k:j]
perm.append(source[i])
k += n - m
m = n + 1
perm += axes_orig[k:]
return tuple(perm)
@_primexpr
def _get_moved_shape(shape, perm):
"""
Helper function for moveaxis, returns the permuted shape after
applying perm.
"""
return tuple([shape[i] for i in perm])
[docs]def moveaxis(a, source, destination):
"""
Moves axes of an array to new positions.
Other axes remain in their original order.
Args:
a (Tensor): The array whose axes should be reordered.
source (int, sequence of ints): Original positions of the
axes to move. These must be unique.
destination (int, sequence of ints): Destination positions
for each of the original axes. These must also be unique.
Returns:
Tensor, array with moved axes.
Raises:
ValueError: If axes are out of the range of ``[-a.ndim, a.ndim)``, or
if the axes contain duplicates.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.zeros((3, 4, 5))
>>> output = np.moveaxis(x, 0, -1)
>>> print(output.shape)
(4, 5, 3)
>>> output = np.moveaxis(x, -1, 0)
>>> print(output.shape)
(5, 3, 4)
>>> output = np.moveaxis(x, [0, 1, 2], [-1, -2, -3])
>>> print(output.shape)
(5, 4, 3)
"""
ndim = F.rank(a)
source = _check_axis_valid(source, ndim)
destination = _check_axis_valid(destination, ndim)
if len(source) != len(destination):
_raise_value_error('`source` and `destination` arguments must have the same number of elements')
perm = _get_moved_perm(ndim, source, destination)
return F.transpose(a, perm)
[docs]def tile(a, reps):
"""
Constructs an array by repeating `a` the number of times given by `reps`.
If `reps` has length `d`, the result will have dimension of ``max(d, a.ndim)``.
If ``a.ndim < d``, `a` is promoted to be d-dimensional by prepending new axes.
So a shape (3,) array is promoted to (1, 3) for 2-D replication, or
shape (1, 1, 3) for 3-D replication. If this is not the desired behavior,
promote `a` to d-dimensions manually before calling this function.
If ``a.ndim > d``, `reps` is promoted to ``a.ndim`` by pre-pending 1's to it. Thus
for an `a` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as (1, 1, 2, 2).
Args:
a (Tensor): The input array.
reps (int, sequence of ints): The number of repetitions of `a` along
each axis.
Returns:
Tensor, the tiled output array.
Raises:
TypeError: If the input is not a tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> a = np.array([0, 1, 2])
>>> output = np.tile(a, 2)
>>> print(output)
[0 1 2 0 1 2]
>>> output = np.tile(a, (2, 2))
>>> print(output)
[[0 1 2 0 1 2]
[0 1 2 0 1 2]]
>>> output = np.tile(a, (2, 1, 2))
>>> print(output)
[[[0 1 2 0 1 2]]
[[0 1 2 0 1 2]]]
"""
_check_input_tensor(a)
ndim = F.rank(a)
shape = F.shape(a)
reps = _add_unit_axes(reps, ndim)
if _is_shape_empty(shape) or _is_shape_empty(reps):
shape = _add_unit_axes(shape, len(reps))
return _empty(F.dtype(a), _seq_prod(shape, reps))
return F.tile(a, reps)
@_primexpr
def _check_can_broadcast_to(shape, target_shape):
"""Determines if shape can be broadcast to target_shape."""
ndim = len(shape)
ndim_target = len(target_shape)
if ndim > ndim_target:
return False
for i, j in zip(reversed(shape), reversed(target_shape)):
if i not in (1, j):
return False
return True
[docs]def broadcast_to(array, shape):
"""
Broadcasts an array to a new shape.
Args:
array (Tensor): The array to broadcast.
shape (tuple): The shape of the desired array.
Returns:
Tensor, original array broadcast to the given shape.
Raises:
ValueError: If array cannot be broadcast to shape.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.array([1, 2, 3])
>>> output = np.broadcast_to(x, (3, 3))
>>> print(output)
[[1 2 3]
[1 2 3]
[1 2 3]]
"""
def _check(shape_a, shape):
if not _check_can_broadcast_to(shape_a, shape):
_raise_value_error('cannot broadcast with ', shape)
shape_a = F.shape(array)
_check(shape_a, shape)
return _broadcast_to_shape(array, shape)
[docs]def broadcast_arrays(*args):
"""
Broadcasts any number of arrays against each other.
Note:
Numpy argument `subok` is not supported.
In graph mode, returns a tuple of Tensor instead of a list
of Tensor.
Args:
*args (Tensor): The arrays to broadcast.
Returns:
List of Tensor.
Raises:
ValueError: If arrays cannot be broadcast.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.array([[1,2,3]])
>>> y = np.array([[4],[5]])
>>> output = np.broadcast_arrays(x, y)
>>> print(output)
[Tensor(shape=[2, 3], dtype=Int32, value=
[[1, 2, 3],
[1, 2, 3]]), Tensor(shape=[2, 3], dtype=Int32, value=
[[4, 4, 4],
[5, 5, 5]])]
"""
shapes = map(F.shape, args)
out_shape = _infer_out_shape(*shapes)
res = []
for arr in args:
res.append(broadcast_to(arr, out_shape))
return res
[docs]def array_split(x, indices_or_sections, axis=0):
r"""
Splits a tensor into multiple sub-tensors.
Note:
Currently, array_split only supports ``mindspore.float32`` on ``CPU``.
The only difference between ``np.split`` and ``np.array_split`` is that
``np.array_split`` allows indices_or_sections to be an integer that does not
equally divide the axis. For a tensor of length l that should be split into
n sections, it returns :math:`l \% n` sub-arrays of size :math:`l//n + 1` and
the rest of size :math:`l//n`.
Args:
x (Tensor): A Tensor to be divided.
indices_or_sections (Union[int, tuple(int), list(int)]):
If integer, :math:`N`, the tensor will be divided into
:math:`N` tensors along axis.
If tuple(int), list(int) or of sorted integers,
the entries indicate where along axis the array is split.
For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
If an index exceeds the dimension of the array along axis,
an empty sub-array is returned correspondingly.
axis (int): The axis along which to split. Default: ``0`` .
Returns:
A list of sub-tensors.
Raises:
TypeError: If argument `indices_or_sections` is not integer,
tuple(int) or list(int) or argument `axis` is not integer.
ValueError: If argument `axis` is out of range of :math:`[-x.ndim, x.ndim)`.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> input_x = np.arange(9).astype("float32")
>>> output = np.array_split(input_x, 4)
>>> print(output)
(Tensor(shape=[3], dtype=Float32,
value= [ 0.00000000e+00, 1.00000000e+00, 2.00000000e+00]),
Tensor(shape=[2], dtype=Float32,
value= [ 3.00000000e+00, 4.00000000e+00]),
Tensor(shape=[2], dtype=Float32,
value= [ 5.00000000e+00, 6.00000000e+00]),
Tensor(shape=[2], dtype=Float32,
value= [ 7.00000000e+00, 8.00000000e+00]))
"""
return _split(x, indices_or_sections, opname="array_split", axis=axis)
[docs]def split(x, indices_or_sections, axis=0):
"""
Splits a tensor into multiple sub-tensors along the given axis.
Args:
x (Tensor): A Tensor to be divided.
indices_or_sections (Union[int, tuple(int), list(int)]):
If integer, :math:`N`, the tensor will be divided into
:math:`N` equal tensors along axis.
If tuple(int), list(int) or of sorted integers,
the entries indicate where along axis the array is split.
For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
If an index exceeds the dimension of the array along axis,
an empty sub-array is returned correspondingly.
axis (int, optional): The axis along which to split. Default: ``0`` .
Returns:
A tuple of sub-tensors.
Raises:
TypeError: If argument `indices_or_sections` is not integer,
tuple(int) or list(int) or argument `axis` is not integer.
ValueError: If argument `axis` is out of range of :math:`[-x.ndim, x.ndim)`.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> input_x = np.arange(9).astype("float32")
>>> output = np.split(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 _split(x, indices_or_sections, opname="split", axis=axis)
def _split(x, indices_or_sections, opname, axis=0):
"""Splits a tensor based on ``np.split`` or ``np.array_split``."""
_check_input_tensor(x)
_ = _check_axis_type(axis, True, False, False)
axis_new = _canonicalize_axis(axis, x.ndim)
res = None
arr_shape = x.shape
length_along_dim = arr_shape[axis_new]
if isinstance(indices_or_sections, int):
if indices_or_sections > length_along_dim:
_raise_value_error("empty tensor encountered.")
if opname == "split" or length_along_dim % indices_or_sections == 0:
res = P.Split(axis_new, indices_or_sections)(x)
else:
num_long_tensor = length_along_dim % indices_or_sections
num_short_tensor = indices_or_sections - num_long_tensor
length1 = num_long_tensor * (length_along_dim // indices_or_sections + 1)
length2 = length_along_dim - length1
start1 = _list_comprehensions(F.rank(x), 0, True)
size1 = _tuple_setitem(arr_shape, axis_new, length1)
start2 = _tuple_setitem(start1, axis_new, length1)
size2 = _tuple_setitem(arr_shape, axis_new, length2)
res = P.Split(axis_new, num_long_tensor)(F.tensor_slice(x, start1, size1)) + \
P.Split(axis_new, num_short_tensor)(F.tensor_slice(x, start2, size2))
elif isinstance(indices_or_sections, (list, tuple)) and _check_element_int(indices_or_sections):
res = _split_sub_tensors(x, indices_or_sections, axis_new)
else:
_raise_type_error("Argument `indices_or_sections` in `mindspore.numpy.split`\
should be integer, tuple(int) or list(int), but got", indices_or_sections)
return res
@constexpr
def convert_neg_indices(indices, ndim):
"""converts negative values in tuple/list indices"""
def canonicalizer(ax):
return ax + ndim if ax < 0 else ax
indices = tuple([canonicalizer(axis) for axis in indices])
return indices
def _split_sub_tensors(x, indices, axis):
"""
Splits the input tensor `x` into multiple sub-tensors
along the axis according to the given indices.
"""
length_along_dim = x.shape[axis]
indices = convert_neg_indices(indices, length_along_dim)
indices += (length_along_dim,)
sub_tensors = []
strides = _list_comprehensions(x.ndim, 1, True)
begin = _list_comprehensions(x.ndim, 0)
end = _list_comprehensions(x.shape)
for i, idx in enumerate(indices):
begin[axis] = 0 if i == 0 else indices[i - 1]
end[axis] = idx
if end[axis] <= begin[axis]:
_raise_value_error("empty sub-tensor encountered.")
sliced_tensor = F.strided_slice(x, _type_convert(tuple, begin), _type_convert(tuple, end), strides)
sub_tensors.append(sliced_tensor)
return sub_tensors
[docs]def vsplit(x, indices_or_sections):
"""
Splits a tensor into multiple sub-tensors vertically (row-wise).
It is equivalent to split with :math:`axis=0` (default), the array is always
split along the first axis regardless of the array dimension.
Args:
x (Tensor): A Tensor to be divided.
indices_or_sections (Union[int, tuple(int), list(int)]):
If integer, :math:`N`, the tensor will be divided into
:math:`N` equal tensors along axis.
If tuple(int), list(int) or of sorted integers,
the entries indicate where along axis the array is split.
For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
If an index exceeds the dimension of the array along axis,
an empty sub-array is returned correspondingly.
Returns:
A list of sub-tensors.
Raises:
TypeError: If argument `indices_or_sections` is not integer.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> input_x = np.arange(9).reshape((3, 3)).astype('float32')
>>> output = np.vsplit(input_x, 3)
>>> print(output)
(Tensor(shape=[1, 3], dtype=Float32,
value=[[ 0.00000000e+00, 1.00000000e+00, 2.00000000e+00]]),
Tensor(shape=[1, 3], dtype=Float32,
value=[[ 3.00000000e+00, 4.00000000e+00, 5.00000000e+00]]),
Tensor(shape=[1, 3], dtype=Float32,
value=[[ 6.00000000e+00, 7.00000000e+00, 8.00000000e+00]]))
"""
return split(x, indices_or_sections, 0)
[docs]def hsplit(x, indices_or_sections):
"""
Splits a tensor into multiple sub-tensors horizontally (column-wise).
It is equivalent to split with :math:`axis=1` (default), the array is always
split along the second axis regardless of the array dimension.
Args:
x (Tensor): A Tensor to be divided.
indices_or_sections (Union[int, tuple(int), list(int)]):
If integer, :math:`N`, the tensor will be divided into
:math:`N` equal tensors along axis.
If tuple(int), list(int) or of sorted integers,
the entries indicate where along axis the array is split.
For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
If an index exceeds the dimension of the array along axis,
an empty sub-array is returned correspondingly.
Returns:
A list of sub-tensors.
Raises:
TypeError: If argument `indices_or_sections` is not integer.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> input_x = np.arange(6).reshape((2, 3)).astype('float32')
>>> output = np.hsplit(input_x, 3)
>>> print(output)
(Tensor(shape=[2, 1], dtype=Float32,
value=[[ 0.00000000e+00],
[ 3.00000000e+00]]),
Tensor(shape=[2, 1], dtype=Float32,
value=[[ 1.00000000e+00],
[ 4.00000000e+00]]),
Tensor(shape=[2, 1], dtype=Float32,
value=[[ 2.00000000e+00],
[ 5.00000000e+00]]))
"""
return split(x, indices_or_sections, 1)
[docs]def dsplit(x, indices_or_sections):
"""
Splits a tensor into multiple sub-tensors along the 3rd axis (depth).
It is equivalent to split with :math:`axis=2` (default), the array is always
split along the third axis regardless of the array dimension.
Args:
x (Tensor): A Tensor to be divided.
indices_or_sections (Union[int, tuple(int), list(int)]):
If integer, :math:`N`, the tensor will be divided into
:math:`N` equal tensors along axis.
If tuple(int), list(int) or of sorted integers,
the entries indicate where along axis the array is split.
For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
If an index exceeds the dimension of the array along axis,
an empty sub-array is returned correspondingly.
Returns:
A list of sub-tensors.
Raises:
TypeError: If argument `indices_or_sections` is not integer.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> input_x = np.arange(6).reshape((1, 2, 3)).astype('float32')
>>> output = np.dsplit(input_x, 3)
>>> print(output)
(Tensor(shape=[1, 2, 1], dtype=Float32,
value=[[[ 0.00000000e+00],
[ 3.00000000e+00]]]),
Tensor(shape=[1, 2, 1], dtype=Float32,
value=[[[ 1.00000000e+00],
[ 4.00000000e+00]]]),
Tensor(shape=[1, 2, 1], dtype=Float32,
value=[[[ 2.00000000e+00],
[ 5.00000000e+00]]]))
"""
return split(x, indices_or_sections, 2)
@_primexpr
def _get_flip_start(ndim, shape, axes):
return tuple([shape[i] - 1 if i in axes else 0 for i in range(ndim)])
@_primexpr
def _get_flip_end(ndim, shape, axes):
return tuple([-shape[i] - 1 if i in axes else shape[i] + 1 for i in range(ndim)])
@_primexpr
def _get_flip_strides(ndim, axes):
return tuple([-1 if i in axes else 1 for i in range(ndim)])
[docs]def flip(m, axis=None):
"""
Reverses the order of elements in an array along the given axis.
The shape of the array is preserved, but the elements are reordered.
Args:
m (Tensor): Input array.
axis (Union[int, tuple(int), None], optional): Axis or axes along which
to flip over. The default, ``axis=None``, will flip over all of the axes
of the input array. If `axis` is negative it counts from the last to
the first axis. If `axis` is a tuple of integers, flipping is performed on
all of the axes specified in the tuple.
Returns:
Tensor, with the entries of `axis` reversed.
Raises:
TypeError: If the input is not a tensor.
Supported Platforms:
``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> A = np.arange(8.0).reshape((2,2,2))
>>> output = np.flip(A)
>>> print(output)
[[[7. 6.]
[5. 4.]]
[[3. 2.]
[1. 0.]]]
>>> output = np.flip(A, (0, 2))
>>> print(output)
[[[5. 4.]
[7. 6.]]
[[1. 0.]
[3. 2.]]]
"""
_check_input_tensor(m)
ndim = F.rank(m)
axes = _check_axis_valid(axis, ndim)
shape = F.shape(m)
dtype = F.dtype(m)
if _is_shape_empty(shape):
return m
if not _check_is_float(dtype):
m = m.astype(mstype.float32)
start = _get_flip_start(ndim, shape, axes)
end = _get_flip_end(ndim, shape, axes)
strides = _get_flip_strides(ndim, axes)
res = F.strided_slice(m, start, end, strides)
if not _check_same_type(F.dtype(res), dtype):
res = F.cast(res, dtype)
return res
[docs]def flipud(m):
"""
Flips the entries in each column in the up/down direction.
Rows are preserved, but appear in a different order than before.
Args:
m (Tensor): Input array.
Returns:
Tensor.
Raises:
TypeError: If the input is not a tensor.
Supported Platforms:
``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> A = np.arange(8.0).reshape((2,2,2))
>>> output = np.flipud(A)
>>> print(output)
[[[4. 5.]
[6. 7.]]
[[0. 1.]
[2. 3.]]]
"""
return flip(m, 0)
[docs]def fliplr(m):
"""
Flips the entries in each row in the left/right direction.
Columns are preserved, but appear in a different order than before.
Args:
m (Tensor): Input array.
Returns:
Tensor.
Raises:
TypeError: If the input is not a tensor.
Supported Platforms:
``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> A = np.arange(8.0).reshape((2,2,2))
>>> output = np.fliplr(A)
>>> print(output)
[[[2. 3.]
[0. 1.]]
[[6. 7.]
[4. 5.]]]
"""
return flip(m, 1)
[docs]def take_along_axis(arr, indices, axis):
"""
Takes values from the input array by matching 1d index and data slices.
This iterates over matching 1d slices oriented along the specified axis in the
index and data arrays, and uses the former to look up values in the latter.
These slices can be different lengths.
Args:
arr (Tensor): Source array with shape `(Ni…, M, Nk…)`.
indices (Tensor): Indices with shape `(Ni…, J, Nk…)` to take along each 1d
slice of `arr`. This must match the dimension of `arr`, but dimensions `Ni`
and `Nj` only need to broadcast against `arr`.
axis (int): The axis to take 1d slices along. If `axis` is None, the input
array is treated as if it had first been flattened to 1d.
Returns:
Tensor, the indexed result, with shape `(Ni…, J, Nk…)`.
Raises:
ValueError: If input array and indices have different number of dimensions.
TypeError: If the input is not a Tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.arange(12).reshape(3, 4)
>>> indices = np.arange(3).reshape(1, 3)
>>> output = np.take_along_axis(x, indices, 1)
>>> print(output)
[[ 0 1 2]
[ 4 5 6]
[ 8 9 10]]
"""
_check_input_tensor(arr, indices)
if axis is None:
arr = ravel(arr)
axis = 0
ndim = F.rank(arr)
if ndim != F.rank(indices):
_raise_value_error('`indices` and `arr` must have the same number of dimensions')
axis = _check_axis_in_range(axis, ndim)
shape_arr = F.shape(arr)
shape_indices = F.shape(indices)
# broadcasts indices against the shape of arr except at axis
indices = _broadcast_to(indices, _tuple_slice(shape_indices, None, axis),
_tuple_slice(shape_arr, None, axis), ndim)
indices = _broadcast_to(indices, _tuple_slice(shape_arr, None, axis + 1) +
_tuple_slice(shape_indices, axis + 1, None), shape_arr, ndim)
arr = _broadcast_to(arr, shape_arr, indices.shape, ndim)
return F.gather_d(arr, axis, indices)
def _mod(x, y):
"""Computes x mod y."""
quotient = F.tensor_floordiv(x, y)
prod = F.tensor_mul(y, quotient)
return F.tensor_sub(x, prod)
def _check_indices(dims, indices, mode, allow_negative_index=True):
"""Checks whether indices are out of bounds."""
shape = F.shape(indices)
dtype = F.dtype(indices)
if not allow_negative_index:
lowerbounds = F.fill(dtype, shape, 0)
else:
lowerbounds = F.fill(dtype, shape, -dims)
upperbounds = F.fill(dtype, shape, dims - 1)
out_of_lowerbounds = F.tensor_lt(indices, lowerbounds)
out_of_upperbounds = F.tensor_gt(indices, upperbounds)
if mode == 'raise':
_raise_unimplemented_error('"raise" mode is not implemented')
if mode == 'wrap':
return _mod(indices, F.fill(mstype.float32, shape, dims)).astype(dtype)
if mode != 'clip':
_raise_value_error('invalid mode. Expected "raise", "wrap", or "clip"')
zeros = F.fill(dtype, shape, 0)
clipped = F.select(out_of_lowerbounds, zeros, indices)
clipped = F.select(out_of_upperbounds, upperbounds, clipped)
return clipped
[docs]def take(a, indices, axis=None, mode='clip'):
"""
Takes elements from an array along an axis.
When axis is not None, this function does the same thing as "fancy" indexing
(indexing arrays using arrays); however, it can be easier to use if you need
elements along a given axis. A call such as ``np.take(arr, indices, axis=3)`` is
equivalent to ``arr[:,:,:,indices,...]``.
Note:
Numpy argument out is not supported.
``mode = 'raise'`` is not supported, and the default mode is 'clip' instead.
Args:
a (Tensor): Source array with shape `(Ni…, M, Nk…)`.
indices (Tensor): The indices with shape `(Nj...)` of the values to extract.
axis (int, optional): The axis over which to select values. By default,
the flattened input array is used. Default: ``None`` .
mode ('raise', 'wrap', 'clip', optional): Specifies how out-of-bounds
indices will behave. Default: ``'clip'`` .
'raise' - raise an error;
'wrap' - wrap around;
'clip' - clip to the range. 'clip' mode means that all indices that are
too large are replaced by the index that addresses the last element
along that axis. Note that this disables indexing with negative numbers.
Returns:
Tensor, the indexed result.
Raises:
ValueError: If axis is out of range.
TypeError: If the input is not a Tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> a = np.array([4, 3, 5, 7, 6, 8])
>>> indices = np.array([0, 1, 4])
>>> output = np.take(a, indices)
>>> print(output)
[4 3 6]
>>> indices = np.array([[0, 1], [2, 3]])
>>> output = np.take(a, indices)
>>> print(output)
[[4 3]
[5 7]]
"""
_check_input_tensor(a, indices)
return a.take(indices, axis, mode)
[docs]def repeat(a, repeats, axis=None):
"""
Repeats elements of an array.
Args:
a (Tensor): Input array.
repeats (int, sequence of ints): The number of repetitions for each element.
`repeats` is broadcasted to fit the shape of the given axis.
axis (int, optional): The axis along which to repeat values. By default,
use the flattened input array, and return a flat output array. Default: ``None`` .
Returns:
Tensor, output array which has the same shape as `a`, except along the given
axis.
Raises:
ValueError: If axis is out of range.
TypeError: If input `a` is not a Tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> output = np.repeat(np.array(3), 4)
>>> print(output)
[3 3 3 3]
>>> x = np.array([[1,2],[3,4]])
>>> output = np.repeat(x, 2)
>>> print(output)
[1 1 2 2 3 3 4 4]
>>> output = np.repeat(x, 3, axis=1)
>>> print(output)
[[1 1 1 2 2 2]
[3 3 3 4 4 4]]
>>> output = np.repeat(x, [1, 2], axis=0)
>>> print(output)
[[1 2]
[3 4]
[3 4]]
"""
a = _to_tensor(a)
return a.repeat(repeats, axis)
[docs]def rot90(a, k=1, axes=(0, 1)):
"""
Rotates a tensor by 90 degrees in the plane specified by axes.
Rotation direction is from the first towards the second axis.
Args:
a (Tensor): Input tensor of two or more dimensions.
k (int): Number of times the tensor is rotated by 90 degrees. Default: ``1`` .
axes (Union[tuple(int), list(int)], optional): The tensor is rotated in the plane
defined by the axes. Default: ``(0, 1)`` .
Axes must be different and with the shape of `(2,)`.
Returns:
Tensor.
Raises:
TypeError: If input `a` is not a Tensor or
the argument `k` is not integer or
the argument `axes` is not tuple of integers or list of ints.
ValueError: If any axis is out of range or
the length of `axes` is not `2`.
Supported Platforms:
``GPU``
Examples:
>>> import mindspore.numpy as np
>>> a = np.arange(24).reshape((2, 3, 4))
>>> output = np.rot90(a)
>>> print(output)
[[[ 8 9 10 11]
[20 21 22 23]]
[[ 4 5 6 7]
[16 17 18 19]]
[[ 0 1 2 3]
[12 13 14 15]]]
>>> output = np.rot90(a, 3, (1, 2))
>>> print(output)
[[[ 8 4 0]
[ 9 5 1]
[10 6 2]
[11 7 3]]
[[20 16 12]
[21 17 13]
[22 18 14]
[23 19 15]]]
"""
_check_input_tensor(a)
if not isinstance(k, int):
_raise_type_error("integer argument expected, but got ", k)
k = k % 4 if k >= 0 else 4 - (-k % 4)
if not isinstance(axes, (tuple, list)):
_raise_type_error("tuple(ints) or list(ints) expected, but got ", axes)
if len(axes) != 2:
_raise_value_error("len(axes) must be 2.")
axis1_tmp, axis2_tmp = axes[0], axes[1]
axis1 = _canonicalize_axis(axis1_tmp, a.ndim)
axis2 = _canonicalize_axis(axis2_tmp, a.ndim)
if axis1 == axis2:
_raise_value_error('Axes must be different.')
if k == 0:
return a
if k == 2:
return flip(flip(a, axis1), axis2)
perm = _list_comprehensions(a.ndim)
perm[axis1], perm[axis2] = perm[axis2], perm[axis1]
if k == 1:
return flip(transpose(a, perm), axis1)
return flip(transpose(a, perm), axis2)
[docs]def select(condlist, choicelist, default=0):
"""
Returns an array drawn from elements in `choicelist`, depending on conditions.
Args:
condlist (Union[int, float, bool, list, tuple, Tensor]): The list of conditions
which determine from which array in `choicelist` the output elements are
taken. When multiple conditions are satisfied, the first one encountered in
`condlist` is used.
choicelist (Union[int, float, bool, list, tuple, Tensor]): The list of arrays
from which the output elements are taken. It has to be of the same length as
`condlist`.
default (scalar, optional): The element inserted in output when all conditions
evaluate to `False`. Default: ``0`` .
Returns:
Tensor, the output at position `m` is the `m-th` element of the array in
`choicelist` where the `m-th` element of the corresponding array in `condlist`
is `True`.
Raises:
ValueError: If ``len(condlist) != len(choicelist)``.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> condlist = [[True, True, True, False, False], [False, False, True, False, True]]
>>> choicelist = [[0, 1, 2, 3, 4], [0, 1, 4, 9, 16]]
>>> output = np.select(condlist, choicelist)
>>> print(output)
[ 0 1 2 0 16]
"""
condlist, choicelist = _to_tensor(condlist, choicelist)
shape_cond = F.shape(condlist)
shape_choice = F.shape(choicelist)
if F.rank(condlist) == 0 or F.rank(choicelist) == 0:
_raise_value_error('input cannot be scalars')
case_num = shape_cond[0]
if shape_choice[0] != case_num:
_raise_value_error('list of cases must be same length as list of conditions')
case_size_cond = _tuple_slice(shape_cond, 1, None)
case_size_choice = _tuple_slice(shape_choice, 1, None)
# performs broadcast over the cases in condlist and choicelist
case_size = _infer_out_shape(case_size_cond, case_size_choice)
shape_broadcasted = (case_num,) + case_size
ndim = len(shape_broadcasted)
shape_cond_expanded = ((case_num,) + _list_comprehensions(ndim - F.rank(condlist), 1, True) +
case_size_cond)
condlist = _broadcast_to_shape(F.reshape(condlist, shape_cond_expanded), shape_broadcasted)
shape_choice_expanded = ((case_num,) + _list_comprehensions(ndim - F.rank(choicelist), 1, True) +
case_size_choice)
choicelist = _broadcast_to_shape(F.reshape(choicelist, shape_choice_expanded), shape_broadcasted)
slice_start = _list_comprehensions(ndim - 1, 0, True)
slice_size = (1,) + case_size
dtype = F.dtype(choicelist)
if isinstance(default, Tensor):
default_slice = default.astype(F.dtype(choicelist)).reshape(slice_size)
else:
default_slice = F.fill(F.dtype(choicelist), slice_size, default)
for i in range(case_num - 1, -1, -1):
cond_slice = F.tensor_slice(condlist.astype(mstype.float32), (i,) + slice_start, slice_size)
choice_slice = F.tensor_slice(choicelist, (i,) + slice_start, slice_size)
default_slice = F.select(cond_slice.astype(mstype.bool_), choice_slice, default_slice)
return F.reshape(default_slice, (case_size)).astype(dtype)
@_primexpr
def _get_grid(shape):
"""Returns a grid representing all the indices for an array with the given shape."""
grids = []
ndim = len(shape)
for i in range(ndim):
dim_grid = _iota(mstype.int32, shape[i])
dim_shape = _expanded_shape(ndim, shape[i], i)
dim_grid = _broadcast_to_shape(dim_grid.reshape(dim_shape), shape)
grids.append(dim_grid)
return stack(grids, -1)
[docs]def choose(a, choices, mode='clip'):
"""
Construct an array from an index array and a list of arrays to choose from.
Given an "index" array `a` of integers and a sequence of n arrays (choices),
`a` and each choice array are first broadcast, as necessary, to arrays of a
common shape; calling these `Ba` and `Bchoices[i], i = 0,…,n-1` we have that,
necessarily, ``Ba.shape == Bchoices[i].shape`` for each `i`. Then, a new array
with ``shape Ba.shape`` is created as follows:
- if ``mode='raise'`` (the default), then, first of all, each element of `a`
(and thus `Ba`) must be in the range `[0, n-1]`; now, suppose that `i`
(in that range) is the value at the `(j0, j1, ..., jm)` position in
`Ba` - then the value at the same position in the new array is the
value in ``Bchoices[i]`` at that same position;
- if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed)
integer; modular arithmetic is used to map integers outside the
range ``[0, n-1]`` back into that range; and then the new array is
constructed as above;
- if ``mode='clip'``, values in `a` (and thus `Ba`) may be any (signed) integer;
negative integers are mapped to 0; values greater than `n-1` are mapped to
`n-1`; and then the new array is constructed as above.
Note:
Numpy argument `out` is not supported.
``mode = 'raise'`` is not supported, and the default mode is 'clip' instead.
Args:
a (int array): This array must contain integers in ``[0, n-1]``, where `n` is
the number of choices, unless ``mode=wrap`` or ``mode=clip``, in which
cases any integers are permissible.
choices (sequence of arrays): Choice arrays. `a` and all of the `choices` must
be broadcastable to the same shape. If `choices` is itself an array, then
its outermost dimension (i.e., the one corresponding to ``choices.shape[0]``)
is taken as defining the "sequence".
mode ('raise', 'wrap', 'clip', optional): Specifies how indices outside
``[0, n-1]`` will be treated:
'raise' - raise an error;
'wrap' - wrap around;
'clip' - clip to the range. 'clip' mode means that all indices that are
too large are replaced by the index that addresses the last element
along that axis. Note that this disables indexing with negative numbers.
Returns:
Tensor, the merged result.
Raises:
ValueError: If `a` and any of the `choices` cannot be broadcast.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33]]
>>> print(np.choose([2, 3, 1, 0], choices))
[20 31 12 3]
>>> print(np.choose([2, 4, 1, 0], choices, mode='clip'))
[20 31 12 3]
>>> print(np.choose([2, 4, 1, 0], choices, mode='wrap'))
[20 1 12 3]
>>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
>>> choices = [-10, 10]
>>> print(np.choose(a, choices))
[[ 10 -10 10]
[-10 10 -10]
[ 10 -10 10]]
"""
a = _to_tensor(a)
if not _check_is_int(F.dtype(a)):
_raise_value_error('`a` should be an int array')
if isinstance(choices, (tuple, list)):
# broadcasts choices to the same shape if choices is a sequence
choices = _to_tensor(*choices)
shapes = ()
for choice in choices:
shapes += (F.shape(choice),)
shape_choice = _infer_out_shape(F.shape(a), *shapes)
tmp = []
for choice in choices:
tmp.append(broadcast_to(choice, shape_choice))
choices = stack(tmp)
else:
choices = _to_tensor(choices)
shape_choice = _infer_out_shape(F.shape(a), F.shape(choices)[1:])
choices = F.reshape(choices, choices.shape[:1] + _add_unit_axes(choices.shape[1:], len(shape_choice)))
choices = broadcast_to(choices, (F.shape(choices)[0],) + shape_choice)
if F.rank(a) == 0 or F.rank(choices) == 0:
_raise_value_error('input cannot be scalars')
a = broadcast_to(a, shape_choice)
a = _check_indices(F.shape(choices)[0], a, mode, allow_negative_index=False)
grid = _get_grid(F.shape(a))
indices = concatenate((a.reshape(F.shape(a) + (1,)), grid), -1)
return F.gather_nd(choices, indices)
[docs]def size(a, axis=None):
"""
Returns the number of elements along a given axis.
Args:
a (Union[int, float, bool, list, tuple, Tensor]): Input data.
axis (int, optional): Axis along which the elements are counted. Default: ``None``.
If None, give the total number of elements.
Returns:
Number of elements along the specified axis.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If input is not array_like or `axis` is not int.
ValueError: If any axis is out of range or duplicate axes exist.
Examples:
>>> import mindspore.numpy as np
>>> x = np.arange(10).reshape(2, 5).astype('float32')
>>> print(np.size(x))
10
>>> print(np.size(x, axis=1))
5
"""
a = _to_tensor(a)
if axis is None:
return a.size
if not isinstance(axis, int):
_raise_type_error("axis argument should be integer.")
axis = _canonicalize_axis(axis, a.ndim)
return a.shape[axis]
[docs]def array_str(a):
"""
Returns a string representation of the data in an array.
The data in the array is returned as a single string.
This function is similar to array_repr, the difference being that array_repr also
returns information on the kind of array and its data type.
Note:
Numpy argument `max_line_width`, `precision` and `suppress_small` are not supported.
Graph mode does not support the function.
Args:
a (Tensor): Input data.
Returns:
String.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
TypeError: If input is not tensor.
Examples:
>>> import mindspore.numpy as np
>>> x = np.arange(5)
>>> np.array_str(x)
'[0 1 2 3 4]'
"""
if not isinstance(a, Tensor):
_raise_type_error("Expect input to be tensor.")
return a.__str__()
[docs]def apply_along_axis(func1d, axis, arr, *args, **kwargs):
"""
Applies a function to 1-D slices along the given axis.
Executes ``func1d(a, *args, **kwargs)`` where `func1d` operates on 1-D arrays and `a` is a
1-D slice of arr along axis.
Args:
func1d (function): Maps `(M,) -> (Nj…)`. This function should accept 1-D arrays. It is
applied to 1-D slices of arr along the specified axis.
axis (int): Axis along which arr is sliced.
arr (Tensor): Input array with shape `(Ni…, M, Nk…)`.
args (any): Additional arguments to `func1d`.
kwargs (any): Additional named arguments to `func1d`.
Returns:
Tensor with shape `(Ni…, Nj…, Nk…)`, the output array. Its shape is identical to the
shape of `arr`, except along the `axis` dimension. This axis is removed, and replaced
with new dimensions equal to the shape of the return value of `func1d`. So if `func1d`
returns a scalar, the output will have one fewer dimensions than `arr`.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
ValueError: If axis is out of the range.
Examples:
>>> import mindspore.numpy as np
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> print(np.apply_along_axis(np.diag, -1, b))
[[[1 0 0]
[0 2 0]
[0 0 3]]
[[4 0 0]
[0 5 0]
[0 0 6]]
[[7 0 0]
[0 8 0]
[0 0 9]]]
"""
ndim = F.rank(arr)
shape = F.shape(arr)
axis = _check_axis_in_range(axis, ndim)
arr = moveaxis(arr, axis, -1)
arr = F.reshape(arr, (-1, F.shape(arr)[-1]))
slices = []
for i in range(F.shape(arr)[0]):
slices.append(func1d(arr[i], *args, **kwargs))
stacked_slices = stack(slices)
shape_stacked = (_tuple_slice(shape, None, axis) + _tuple_slice(shape, axis + 1, None) +
_tuple_slice(F.shape(stacked_slices), 1, None))
res = F.reshape(stacked_slices, shape_stacked)
# moves the dimensions returned by `func1d` back to `axis`
ndim_func = F.rank(res) - ndim + 1
if ndim_func >= 1:
res = moveaxis(res, F.make_range(ndim - 1, F.rank(res)),
F.make_range(axis, axis + ndim_func))
return res
def _stack_arrays(arrs):
"""Stacks a sequence of Tensor"""
if isinstance(arrs, (tuple, list)):
tensor_list = []
for arr in arrs:
tensor_list.append(_to_tensor(arr))
return stack(tensor_list)
return atleast_1d(_to_tensor(arrs))
[docs]def piecewise(x, condlist, funclist, *args, **kw):
"""
Evaluates a piecewise-defined function.
Given a set of conditions and corresponding functions, evaluate each function on the input
data wherever its condition is true.
Args:
x (Union[int, float, bool, list, tuple, Tensor]): The input domain.
condlist (Union[bool, list[Tensor, bool]]): Each boolean array corresponds to a
function in `funclist`. Wherever `condlist[i]` is True, `funclist[i](x)` is used as
the output value. Each boolean array in `condlist` selects a piece of `x`, and
should therefore be of the same shape as `x`. The length of `condlist` must
correspond to that of `funclist`. If one extra function is given, i.e. if
``len(funclist) == len(condlist) + 1``, then that extra function is the default
value, used wherever all conditions are false.
funclist (Union[list[callables], list[scalars]]): Each function is evaluated over
`x` wherever its corresponding condition is True. It should take a 1d array as input
and give an 1d array or a scalar value as output. If, instead of a callable, a scalar
is provided then a constant function ``(lambda x: scalar)`` is assumed.
args (any): Any further arguments given to `piecewise` are passed to the functions upon
execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then each function is
called as ``f(x, 1, 'a')``.
kw (any): Keyword arguments used in calling `piecewise` are passed to the functions upon
execution, i.e., if called ``piecewise(..., ..., alpha=1)``, then each function is
called as ``f(x, alpha=1)``.
Returns:
Tensor, the output is the same shape and type as `x` and is found by calling the
functions in `funclist` on the appropriate portions of `x`, as defined by the boolean
arrays in `condlist`. Portions not covered by any condition have a default value of 0.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
ValueError: If length of `funclist` is not in ``(len(condlist), len(condlist) + 1)``
Examples:
>>> import mindspore.numpy as np
>>> x = np.linspace(-2.5, 2.5, 6)
>>> print(np.piecewise(x, [x < 0, x >= 0], [-1, 1]))
[-1 -1 -1 1 1 1]
"""
x = _to_tensor(x)
choicelist = funclist
if isinstance(funclist, (tuple, list)):
if _callable(x, funclist[0]):
choicelist = []
for func in funclist:
choicelist.append(func(x, *args, **kw))
condlist = _stack_arrays(condlist)
choicelist = _stack_arrays(choicelist)
default = 0
n1 = len(condlist)
n2 = len(funclist)
if n1 + 1 == n2:
default = choicelist[-1]
choicelist = choicelist[:-1]
elif n1 != n2:
_raise_value_error('the number of choices should be either equal to conditions or ', n1 + 1)
return select(condlist, choicelist, default=default)
[docs]def unravel_index(indices, shape, order='C'):
"""
Converts a flat index or array of flat indices into a tuple of coordinate arrays.
Note:
Out-of-bound indices are clipped by the boundaries of `shape` instead of raising
an error.
Args:
indices (Union[int, float, bool, list, tuple, Tensor]): An integer array whose elements
are indices into the flattened version of an array of dimensions shape.
shape (tuple(int)): The shape of the array to use for unraveling indices.
order (Union['C', 'F'], optional): Determines whether the indices should be viewed as
indexing in row-major (C-style) or column-major (Fortran-style) order. Default: ``'C'`` .
Returns:
Tensor, each array in the tuple has the same shape as the indices array.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Raises:
ValueError: If `order` is not 'C' or 'F'.
Examples:
>>> import mindspore.numpy as np
>>> print(np.unravel_index([22, 41, 37], (7,6)))
(Tensor(shape=[3], dtype=Int32, value= [3, 6, 6]),
Tensor(shape=[3], dtype=Int32, value= [4, 5, 1]))
>>> print(np.unravel_index([31, 41, 13], (7,6), order='F'))
(Tensor(shape=[3], dtype=Int32, value= [3, 6, 6]),
Tensor(shape=[3], dtype=Int32, value= [4, 5, 1]))
"""
indices = _to_tensor(indices)
if order not in ('C', 'F'):
_raise_value_error('invalid order. Expected "C" or "F"')
if isinstance(shape, int):
shape = (shape,)
ndim = F.rank(indices)
if order == 'F':
sizes = _cumprod(shape)
else:
sizes = _cumprod(shape[::-1])
sizes = _to_tensor(sizes[::-1] + (1,))
sizes = F.reshape(sizes, (-1,) + _list_comprehensions(ndim, 1, True))
total_size = sizes[0]
indices = where(indices > total_size - 1, total_size - 1, indices)
if _get_device() == 'GPU':
dtype = F.dtype(total_size)
lowerbounds = (-(total_size.astype(mstype.float32))).astype(dtype)
else:
lowerbounds = -total_size
indices = where(indices < lowerbounds, lowerbounds, indices)
res = _mod(indices, sizes[:-1])//sizes[1:]
num = len(res)
if ndim == 0 and num == 1:
return res.ravel()
if order == 'F':
r = range(num - 1, -1, -1)
else:
r = range(num)
subs = ()
for i in r:
subs += (res[i],)
return subs
[docs]def apply_over_axes(func, a, axes):
"""
Applies a function repeatedly over multiple axes.
`func` is called as `res = func(a, axis)`, where `axis` is the first element of `axes`.
The result `res` of the function call must have either the same dimensions as `a` or
one less dimension. If `res` has one less dimension than `a`, a dimension is inserted before `axis`.
The call to `func` is then repeated for each axis in `axes`, with `res` as the first argument.
Args:
func (function): This function must take two arguments, `func(a, axis)`.
a (Union[int, float, bool, list, tuple, Tensor]): Input tensor.
axes (Union[int, list, tuple]): Axes over which `func` is applied; the elements must be integers.
Returns:
Tensor. The number of dimensions is the same as `a`, but the shape can be different.
This depends on whether `func` changes the shape of its output with respect to its input.
Raises:
TypeError: If input `a` is not array_like or `axes` is not int or sequence of ints.
ValueError: If any axis is out of range or duplicate axes exist.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.arange(10).reshape(2, 5).astype('float32')
>>> print(x)
[[0. 1. 2. 3. 4.]
[5. 6. 7. 8. 9.]]
>>> print(np.apply_over_axes(np.sum, x, axes=0))
[[ 5. 7. 9. 11. 13.]]
"""
a = _to_tensor(a)
if isinstance(axes, int):
axes = (axes,)
res = a
for axis in axes:
res = func(res, axis=axis)
res = F.expand_dims(res, axis) if res.ndim != a.ndim else res
if res.ndim != a.ndim:
_raise_value_error("function is not returning a tensor of the correct shape")
return res
[docs]def argwhere(a):
"""
Find the indices of Tensor elements that are non-zero, grouped by element.
Args:
a (Union[list, tuple, Tensor]): Input tensor.
Returns:
Tensor. Indices of elements that are non-zero. Indices are grouped by element.
This Tensor will have shape :math:`(N, a.ndim)` where :math:`N` is the number of non-zero items.
Raises:
TypeError: If input `a` is not array_like.
ValueError: If dim of `a` equals to 0.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> x = np.array([[[1, 0], [-5, 0]]])
>>> np.argwhere(x)
Tensor(shape=[2, 3], dtype=Int64, value=[[0, 0, 0], [0, 1, 0]])
"""
a = _to_tensor(a)
return F.argwhere(a)
[docs]def intersect1d(ar1, ar2, assume_unique=False, return_indices=False):
"""
Find the intersection of two Tensors.
Return the sorted, unique values that are in both of the input Tensors.
Args:
ar1 (Union[int, float, bool, list, tuple, Tensor]): Input tensor.
ar2 (Union[int, float, bool, list, tuple, Tensor]): Input tensor.
assume_unique (bool): If `True`, the input Tensors are assumed to be unique, which can speed up the calculation.
If `True` but `ar1` or `ar2` are not unique,
incorrect results and out-of-bounds indices could result.
Default: ``False``.
return_indices (bool): If `True`, the indices which correspond to the intersection of two Tensors are returned.
The first instance of a value is used if there are multiple.
Default: ``False``.
Returns:
Tensor or tuple of Tensors.
If `return_indices` is ``False``, return the intersection tensor, otherwise return tuple of tensors.
Raises:
TypeError: If input `ar1` or `ar2` is not array_like.
TypeError: If `assume_unique` or `return_indices` is not bool.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> import mindspore.numpy as np
>>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
Tensor(shape=[2], dtype=Int32, value=[1, 3])
"""
def unique_w_ind(arr):
array, sort_indices = arr.ravel().sort()
array_type = array.dtype
cmp_array1 = F.cat((array, Tensor([0], dtype=array_type)))
cmp_array2 = F.cat((Tensor([0], dtype=array_type), array))
mask = cmp_array1 != cmp_array2
mask[0] = True
array = F.masked_select(array, mask[:-1])
ind = F.masked_select(sort_indices, mask[:-1])
return array, ind
if not isinstance(assume_unique, bool) or not isinstance(return_indices, bool):
_raise_type_error("assume_unique or return_indices is not bool type.")
ar1, ar2 = _to_tensor(ar1, ar2)
ind1 = F.fill(mstype.int32, (ar1.size,), -1)
ind2 = F.fill(mstype.int32, (ar2.size,), -1)
if not assume_unique:
if return_indices:
array1, ind1 = unique_w_ind(ar1)
array2, ind2 = unique_w_ind(ar2)
else:
array1 = F.unique(ar1)[0]
array2 = F.unique(ar2)[0]
else:
array1 = ar1.ravel()
array2 = ar2.ravel()
concat_array = concatenate((array1, array2))
if return_indices:
concat_sort_indices = F.argsort(concat_array)
concat_array = concat_array[concat_sort_indices]
else:
concat_array, concat_sort_indices = concat_array.sort()
mask_res = concat_array[1:] == concat_array[:-1]
res = F.masked_select(concat_array[1:], mask_res)
if return_indices:
ar1_indices = F.masked_select(concat_sort_indices[:-1], mask_res)
ar2_indices = F.masked_select(concat_sort_indices[1:], mask_res)
if ar2_indices.shape[0] > 0:
ar2_indices = ar2_indices - array1.size
if not assume_unique:
ar1_indices = ind1.index_select(0, ar1_indices)
ar2_indices = ind2.index_select(0, ar2_indices)
return res, ar1_indices, ar2_indices
return res