mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/ops/composite/array_ops.py

@@ -1,210 +0,0 @@
-# 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."""
-from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
-from mindspore.common import dtype as mstype
-from mindspore.common._register_for_tensor import tensor_operator_registry
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
-from mindspore.ops.primitive import constexpr
-from mindspore.ops import functional as F
-from .. import operations as P
-
-
-@constexpr
-def _check_is_int(arg_value, arg_name, op_name):
-    arg_value = validator.check_is_int(arg_value, arg_name, op_name)
-    return arg_value
-
-
-@constexpr
-def _check_positive_int(arg_value, arg_name, op_name):
-    arg_value = validator.check_positive_int(arg_value, arg_name, op_name)
-    return arg_value
-
-
-@constexpr
-def _check_axis_range(arg_value, limit, arg_name, op_name):
-    arg_value = validator.check_int_range(arg_value, -limit, limit, Rel.INC_LEFT, arg_name, op_name)
-    return arg_value
-
-
-@constexpr
-def _cal_repeat_dims(x_rank, rep, expand_axis):
-    rep_dims = [1] * (x_rank + 1)
-    rep_dims[expand_axis] = rep
-    return tuple(rep_dims)
-
-
-@constexpr
-def _cal_reshape(x_shape, rep, axis):
-    x_reshape = list(x_shape)
-    x_reshape[axis] *= rep
-    return tuple(x_reshape)
-
-
-def repeat_elements(x, rep, axis=0):
-    """
-    Repeat elements of a tensor along an axis, like `np.repeat` .
-
-    Args:
-        x (Tensor): The tensor to repeat values for. Must be of type: float16,
-            float32, int8, uint8, int16, int32, or int64.
-        rep (int): The number of times to repeat, must be positive.
-        axis (int): The axis along which to repeat, default 0.
-
-    Returns:
-        One tensor with values repeated along the specified axis. If x has shape
-        (s1, s2, ..., sn) and axis is i, the output will have shape (s1, s2, ...,
-        si * rep, ..., sn). The output type will be the same as the type of `x`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> import mindspore
-        >>> import numpy as np
-        >>> # case 1 : repeat on axis 0
-        >>> x = Tensor(np.array([[0, 1, 2], [3, 4, 5]]), mindspore.int32)
-        >>> output = ops.repeat_elements(x, rep = 2, axis = 0)
-        >>> print(output)
-        [[0 1 2]
-         [0 1 2]
-         [3 4 5]
-         [3 4 5]]
-        >>> # case 2 : repeat on axis 1
-        >>> x = Tensor(np.array([[0, 1, 2], [3, 4, 5]]), mindspore.int32)
-        >>> output = ops.repeat_elements(x, rep = 2, axis = 1)
-        >>> print(output)
-        [[0 0 1 1 2 2]
-         [3 3 4 4 5 5]]
-    """
-    const_utils.check_type_valid(F.dtype(x), mstype.number_type, 'input x')
-    rep = _check_positive_int(rep, "rep", "repeat_elements")
-    axis = _check_is_int(axis, "axis", "repeat_elements")
-
-    shape_op = P.Shape()
-    rank_op = P.Rank()
-    tile_op = P.Tile()
-    expand_dims_op = P.ExpandDims()
-    reshape_op = P.Reshape()
-
-    x_rank = rank_op(x)
-    axis = _check_axis_range(axis, x_rank, "axis", "repeat_elements")
-
-    expand_axis = axis + 1
-    x_expand = expand_dims_op(x, expand_axis)
-    rep_dims = _cal_repeat_dims(x_rank, rep, expand_axis)
-    x_expand = tile_op(x_expand, rep_dims)
-    x_shape = shape_op(x)
-    x_reshape = _cal_reshape(x_shape, rep, axis)
-    x_rep = reshape_op(x_expand, x_reshape)
-
-    return x_rep
-
-tensor_operator_registry.register('repeat_elements', repeat_elements)
-
-
-@constexpr
-def _check_sequence_mask_input_len(input_shape, prim_name=None):
-    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
-    if not input_shape:
-        raise ValueError(f"{msg_prefix} input_shape must be greater than 0, but got {input_shape}.")
-    # broadcast only supports 7d shape
-    shape_size = len(input_shape)
-    if shape_size >= 7:
-        raise ValueError(f"{msg_prefix} dimension of input_shape must be less than 7, but got {shape_size}d.")
-
-
-def sequence_mask(lengths, maxlen=None):
-    """
-    Returns a mask tensor representing the first N positions of each cell.
-
-    If `lengths` has shape (d_1, d_2, ..., d_n), then the resulting tensor mask has type and shape
-    (d_1, d_2, ..., d_n, maxlen), with mask[i_1, i_2, ..., i_n, j] = (j < lengths[i_1, i_2, ..., i_n])
-
-    Args:
-        lengths (Tensor): Tensor to calculate the mask for. All values in this tensor should be
-            less than or equal to `maxlen`. Values greater than `maxlen` will be treated as `maxlen`.
-        maxlen (int): size of the last dimension of returned tensor. Must be positive and same
-            type as elements in `lengths`. Default is None.
-
-    Returns:
-        One mask tensor of shape `lengths.shape + (maxlen,)` .
-
-    Raises:
-        TypeError: If `lengths` is not a Tensor.
-        TypeError: If `maxlen` is not an int.
-        TypeError: If dtype of `lengths` is neither int32 nor int64.
-
-    Supported Platforms:
-        ``GPU``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> import mindspore
-        >>> import numpy as np
-        >>> # case 1: When maxlen is assigned
-        >>> x = Tensor(np.array([1, 2, 3, 4]))
-        >>> output = ops.sequence_mask(x, 5)
-        >>> print(output)
-        [[ True False False False False]
-         [ True  True False False False]
-         [ True  True  True False False]
-         [ True  True  True  True False]]
-        >>> # case 2: When there is 0 in x
-        >>> x = Tensor(np.array([[1, 3], [2, 0]]))
-        >>> output = ops.sequence_mask(x, 5)
-        >>> print(output)
-        [[[ True False False False False]
-          [ True  True  True False False]]
-         [[ True  True False False False]
-          [False False False False False]]]
-        >>> # case 3: when the maxlen is not assigned
-        >>> x = Tensor(np.array([[1, 3], [2, 4]]))
-        >>> output = ops.sequence_mask(x)
-        >>> print(output)
-        [[[ True False False False ]
-          [ True  True  True False ]]
-         [[ True  True False False ]
-          [ True  True  True  True ]]]
-    """
-
-    argmax_op = P.ArgMaxWithValue()
-    reshape_op = P.Reshape()
-    range_op = P.Range()
-    expand_op = P.ExpandDims()
-    cast_op = P.Cast()
-    shape_op = P.Shape()
-    to_tensor_op = P.ScalarToArray()
-
-    const_utils.check_type_valid(F.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
-    _check_sequence_mask_input_len(shape_op(lengths), "sequence_mask")
-
-    if maxlen is None:
-        flatten_data = reshape_op(lengths, (-1,))
-        flatten_data = cast_op(flatten_data, mstype.float32)
-        _, value = argmax_op(flatten_data)
-        maxlen = cast_op(value, mstype.int32)
-    else:
-        maxlen = _check_positive_int(maxlen, "maxlen", "sequence_mask")
-        maxlen = to_tensor_op(maxlen)
-
-    range_vector = range_op(to_tensor_op(0), maxlen
-                            , to_tensor_op(1))
-    mask = expand_op(lengths, -1)
-    result = range_vector < mask
-    return result

mindspore/ops/composite/clip_ops.py

@@ -1,238 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-"""Operations for clipping tensors to min/max values."""
-from __future__ import absolute_import
-
-import numpy as np
-from mindspore.nn.cell import Cell
-from mindspore.ops import composite as C
-from mindspore.ops import functional as F
-from mindspore.ops import operations as P
-from mindspore.common.tensor import Tensor
-from mindspore.common import dtype as mstype
-from mindspore._checkparam import Rel
-from mindspore._checkparam import Validator as validator
-from mindspore.ops.primitive import constexpr
-
-
-@constexpr
-def _check_output_shape(input_shape, out_shape, prim_name=None):
-    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
-    if input_shape != out_shape:
-        raise ValueError(f"{msg_prefix} input 'x' shape must be equal to the output shape, but got "
-                         f"input 'x' shape {input_shape}, output shape {out_shape}.")
-
-
-def check_np_type(np_dtype, is_max_val):
-    if not (np.issubsctype(np_dtype, np.floating) or np.issubsctype(np_dtype, np.integer) or
-            np.issubsctype(np_dtype, np.complex64) or np.issubsctype(np_dtype, np.complex128) or
-            np.issubsctype(np_dtype, np.bool_)):
-        value_info = ("clip_value_max", "clip_value_min") if is_max_val else ("clip_value_min", "clip_value_max")
-        raise ValueError(f"When {value_info[0]} is none, The date type of {value_info[1]} only support integer,"
-                         f"floating, bool, complex64 or complex128. But got {np_dtype}")
-
-
-@constexpr
-def create_max_min_value(ms_type, is_max_val):
-    """create max or min value"""
-    np_dtype = mstype.dtype_to_nptype(ms_type)
-    check_np_type(np_dtype, is_max_val)
-    if np.issubsctype(np_dtype, np.floating):
-        val = np.finfo(np_dtype).max if is_max_val else np.finfo(np_dtype).min
-    elif np.issubsctype(np_dtype, np.integer):
-        val = np.iinfo(np_dtype).max if is_max_val else np.iinfo(np_dtype).min
-    elif np.issubsctype(np_dtype, np.complex64):
-        val = np.finfo(np.float32).max if is_max_val else np.finfo(np.float32).min
-        val = np.complex64(np.complex(val, val))
-    elif np.issubsctype(np_dtype, np.complex128):
-        val = np.finfo(np.float64).max if is_max_val else np.finfo(np.float64).min
-        val = np.complex128(np.complex(val, val))
-    else:
-        val = np.bool_(True) if is_max_val else np.bool_(False)
-    return Tensor(val, ms_type)
-
-
-@constexpr
-def raise_value_error():
-    raise ValueError("At least one of 'clip_value_min' or 'clip_value_max' must not be None")
-
-
-def clip_by_value(x, clip_value_min=None, clip_value_max=None):
-    r"""
-    Clips tensor values to a specified min and max.
-
-    Limits the value of :math:`x` to a range, whose lower limit is `clip_value_min`
-    and upper limit is `clip_value_max` .
-
-    .. math::
-
-        out_i= \left\{
-        \begin{array}{align}
-            clip\_value\_max & \text{ if } x_i\ge  clip\_value\_max \\
-            x_i & \text{ if } clip\_value\_min \lt x_i \lt clip\_value\_max \\
-            clip\_value\_min & \text{ if } x_i \le clip\_value\_min \\
-        \end{array}\right.
-
-    Note:
-        `clip_value_min` needs to be less than or equal to `clip_value_max` . The data type of x, `clip_value_min` and
-        `clip_value_max` should support implicit type conversion and cannot all be bool type.
-
-    Args:
-          x (Tensor): Input data. The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-          clip_value_min (Tensor): The minimum value. `clip_value_min` and `clip_value_max` cannot be all None.
-                                   Default: None.
-          clip_value_max (Tensor): The maximum value. `clip_value_min` and `clip_value_max` cannot be all None.
-                                   Default: None.
-
-    Returns:
-          Tensor, a clipped Tensor. The data type is the one with higher precision or higher digits among
-          the x, `clip_value_min` and `clip_value_max` .
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> import numpy as np
-        >>> min_value = Tensor(5, mindspore.float32)
-        >>> max_value = Tensor(20, mindspore.float32)
-        >>> x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clip_by_value(x, min_value, max_value)
-        >>> print(output)
-        [[ 5. 20.  5.  7.]
-         [ 5. 11.  6. 20.]]
-    """
-
-    min_op = P.Minimum()
-    max_op = P.Maximum()
-    if clip_value_min is None and clip_value_max is None:
-        raise_value_error()
-    if clip_value_min is None:
-        clip_value_min = create_max_min_value(F.dtype(clip_value_max), False)
-    if clip_value_max is None:
-        clip_value_max = create_max_min_value(F.dtype(clip_value_min), True)
-    x_min = min_op(x, clip_value_max)
-    x_max = max_op(x_min, clip_value_min)
-    _check_output_shape(F.shape(x), F.shape(x_max), 'clip_by_value')
-    return x_max
-
-
-# The attribute grad_scale is needed for enabling the parallel mode
-# If this is removed, c.clip_by_global_norm will have precision error in semi/auto parallel mode.
-expand_dims = P.ExpandDims().add_prim_attr("grad_scale", True)
-
-
-get_square_sum = C.MultitypeFuncGraph("get_square_sum")
-@get_square_sum.register("Tensor")
-def _get_square_sum(x):
-    norm = P.ReduceSum(False)(F.square(x), ())
-    norm = expand_dims(F.cast(norm, mstype.float32), 0)
-    return norm
-
-
-apply_global_norm = C.MultitypeFuncGraph("apply_global_norm")
-@apply_global_norm.register("Tensor", "Tensor", "Tensor")
-def _apply_global_norm(clip_norm, global_norm, x):
-    x_dtype = F.dtype(x)
-    x = x * clip_norm / global_norm
-    x = F.cast(x, x_dtype)
-    return x
-
-
-class _ClipByGlobalNorm(Cell):
-    r"""
-    Clips tensor values by the ratio of the sum of their norms.
-
-    Args:
-        clip_norm (Union(float, int)): The clipping ratio. Default: 1.0
-        use_norm (Union(float, None)): The global norm. Default: None
-
-    Inputs:
-        - **x** (Union(tuple[Tensor], list[Tensor])) - Input data to clip.
-
-    Outputs:
-        Tensor, a clipped Tensor.
-    """
-
-    def __init__(self, clip_norm=1.0, use_norm=None):
-        """Initialize _ClipByGlobalNorm."""
-        super(_ClipByGlobalNorm, self).__init__()
-        # Add interface. This parameter is not used at present
-        if use_norm is not None:
-            raise ValueError(f"For '{self.cls_name}', input 'use_norm' only supports None currently, "
-                             f"but got 'use_norm': {use_norm}")
-        validator.check_number("clip_norm", clip_norm, 0.0, Rel.GT, self.cls_name)
-        self.clip_norm = Tensor([clip_norm], mstype.float32)
-        self.hyper_map = C.HyperMap()
-        self.greater_equal = P.GreaterEqual()
-
-    def construct(self, x):
-        square_sum = self.hyper_map(get_square_sum, x)
-        global_norm = F.sqrt(F.addn(square_sum))
-        cond = self.greater_equal(global_norm, self.clip_norm)
-        global_norm = F.select(cond, global_norm, self.clip_norm)
-        clip_x = self.hyper_map(F.partial(apply_global_norm, self.clip_norm, global_norm), x)
-        return clip_x
-
-
-@constexpr
-def _check_value(clip_norm):
-    validator.check_number("clip_norm", clip_norm, 0.0, Rel.GT, "clip_by_global_norm")
-    return clip_norm
-
-
-def clip_by_global_norm(x, clip_norm=1.0, use_norm=None):
-    r"""
-    Clips tensor values by the ratio of the sum of their norms.
-
-    Note:
-        - Input `x` should be a tuple or list of tensors. Otherwise, it will raise an error.
-        - On the SEMI_AUTO_PARALLEL mode or AUTO_PARALLEL mode, if the input `x` is the gradient,
-          the gradient norm values on all devices will be automatically aggregated by allreduce inserted
-          after the local square sum of the gradients.
-
-    Args:
-        x (Union(tuple[Tensor], list[Tensor])): Input data to clip.
-          The shape of each Tensor in tuple is :math:`(N,*)` where :math:`*` means,
-          any number of additional dimensions.
-        clip_norm (Union(float, int)): The clipping ratio, it should be greater than 0. Default: 1.0
-        use_norm (None): The global norm. Default: None. Currently only none is supported.
-
-    Returns:
-        tuple[Tensor], a clipped Tensor. It has the same data type as `x` and each Tensor in the output tuple is the
-        same as the original input shape.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> import numpy as np
-        >>> x1 = np.array([[2., 3.], [1., 2.]]).astype(np.float32)
-        >>> x2 = np.array([[1., 4.], [3., 1.]]).astype(np.float32)
-        >>> input_x = (Tensor(x1), Tensor(x2))
-        >>> out = ops.clip_by_global_norm(input_x, 1.0)
-        >>> print(out)
-        (Tensor(shape=[2, 2], dtype=Float32, value=
-        [[ 2.98142403e-01,  4.47213590e-01],
-         [ 1.49071202e-01,  2.98142403e-01]]), Tensor(shape=[2, 2], dtype=Float32, value=
-        [[ 1.49071202e-01,  5.96284807e-01],
-         [ 4.47213590e-01,  1.49071202e-01]]))
-    """
-
-    clip_norm = _check_value(clip_norm)
-    clip_val = _ClipByGlobalNorm(clip_norm, use_norm)(x)
-    return clip_val