mindspore 2.2.14__cp39-cp39-manylinux1_x86_64.whl → 2.3.0rc1__cp39-cp39-manylinux1_x86_64.whl

mindspore/_extends/parse/standard_method.py

@@ -20,11 +20,12 @@ from __future__ import absolute_import
 from mindspore import Tensor, CSRTensor, COOTensor
 from mindspore import dtype as mstype
 from mindspore._c_expression import Tensor as Tensor_
-from mindspore.common import mutable
 import mindspore.common._monad as monad
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
     _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
+from mindspore.ops.operations._sequence_ops import TensorToTuple
+from mindspore.ops_generate.gen_ops_inner_prim import ListToTuple, TupleToList
 
 from ... import _checkparam as validator
 from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
@@ -34,13 +35,14 @@ from ...ops import operations as P
 from ...ops import composite
 from ...ops.operations import array_ops
 from ...ops.composite import MultitypeFuncGraph, env_get, hyper_add, \
-    zeros_like, ones_like, repeat_elements
+    zeros_like, ones_like, repeat_elements, multitype_ops
 from ...ops.composite.multitype_ops import _constexpr_utils as const_utils
 from ...ops.composite.multitype_ops import _compile_utils as compile_utils
 from ...ops.operations.math_ops import Median
 from ...ops.operations._inner_ops import Format
 from ...ops.operations import _csr_ops
 from ...ops.operations import _map_tensor_ops
+from ...ops.operations._sequence_ops import TensorToScalar
 from ...ops.primitive import constexpr, _primexpr
 from ...common import dtype as mstype
 from ...ops.operations._sequence_ops import ListAppend, ListInsert, SequenceMax, SequenceMin, \
@@ -549,8 +551,17 @@ def transpose(x, *axis):
     return F.transpose(x, perm)
 
 
+def T(x):
+    """
+    Return the transposed tensor.
+    """
+    if x.ndim <= 1:
+        return x
+    return transpose(x)
+
+
 # `tensor.T` is used as a property in graph mode
-T_ = transpose
+T_ = T
 
 
 def reshape(x, *shape):
@@ -1405,51 +1416,7 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
     if ndim < 2:
         const_utils.raise_value_error(
             'diagonal requires an array of at least two dimensions')
-    dtype = x.dtype
-
-    axes = check_axis_valid((axis1, axis2), ndim)
-    perm = ()
-    for i in range(ndim):
-        if i not in axes:
-            perm += (i,)
-    perm += axes
-    x = x.transpose(perm)
-
-    shape = x.shape
-    n, m = shape[-2:]
-
-    e = F.eye(n, m, dtype)
-    if offset >= m or offset <= -n:
-        zero_shape = shape[:-2] + (0,)
-        return F.zeros(zero_shape, dtype)
-    if offset != 0:
-        e = e.astype(mstype.float32)
-        if offset > 0:
-            e_left = F.fill(dtype, (n, offset), 0)
-            e_right = e[..., 0:m - offset:1]
-            e = P.Concat(1)((e_left, e_right)).astype(dtype)
-        elif offset < 0:
-            e_upper = F.fill(dtype, (-offset, m), 0)
-            e_lower = e[0:n + offset:1, ...]
-            e = P.Concat(0)((e_upper, e_lower)).astype(dtype)
-    e = F.broadcast_to(e, shape)
-
-    prod_val = F.tensor_mul(x, e)
-    res = F.reduce_sum(prod_val.astype(mstype.float32), -1)
-
-    begin = ()
-    for _ in range(ndim - 2):
-        begin += (0,)
-    last_dim_begin = max_(0, -offset)
-    begin += (last_dim_begin,)
-    size = res.shape[:-1]
-    last_dim_end = min_(
-        shape[-2], max_(0, shape[-1] - offset)) - last_dim_begin
-    if last_dim_end <= 0:
-        return empty_compile(dtype, (0,))
-    size += (last_dim_end,)
-    res = F.tensor_slice(res, begin, size)
-    return res.astype(dtype)
+    return F.diagonal(x, offset, axis1, axis2)
 
 
 def diagonal_scatter(input, src, offset, dim1=0, dim2=1):
@@ -1871,7 +1838,7 @@ def searchsorted(x, v, side='left', sorter=None):
     loop_num = get_log2_size(F.shape_mul(a.shape) + 1)
     index = Tensor([0])
     while index < loop_num:
-        mid = (i - F.neg_tensor(j)) // 2
+        mid = (i - F.neg(j)) // 2
         mask = less_op(v, F.gather_nd(a, mid.reshape(mid.shape + (1,))))
         i = F.select(mask, i, mid)
         j = F.select(mask, mid, j)
@@ -2307,6 +2274,10 @@ def hypot(x, other):
     return F.hypot(x, other)
 
 
+def softmax(input, axis, dtype=None):
+    return F.softmax(input, axis, dtype=dtype)
+
+
 def soft_shrink(input, lambd=0.5):
     """Apply the soft shrink function for a tensor. Calculates the output according to the input elements."""
     return F.soft_shrink(input, lambd)
@@ -2342,31 +2313,6 @@ def itemset(data, *args):
     return compile_utils.tensor_itemset(data, *args)
 
 
-def ms_iter(xs):
-    """Implementation of `iter`."""
-    return xs.__ms_iter__
-
-
-def ms_next(it):
-    """Implementation of `next`."""
-    return it.__ms_next__
-
-
-def hasnext(it):
-    """Implementation of `hasnext`."""
-    return it.__ms_hasnext__
-
-
-def str_next(xs):
-    """Next string."""
-    return xs[0], xs[1:]
-
-
-def str_hasnext(xs):
-    """Whether the string is empty or not."""
-    return len(xs) > 0
-
-
 @constexpr
 def cast_to_str(data):
     return str(data)
@@ -2402,7 +2348,8 @@ def bool_func(*data):
         tensor_shape = F.shape(data)
         tensor_shape_len = len(tensor_shape)
         if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
-            return F.scalar_cast(data, mstype.bool_)
+            data = F.cast(data, mstype.bool_)
+            return TensorToScalar()(data)
         raise ValueError("The truth value of an array with more than one element is ambiguous.")
     if not F.isconstant(data):
         if hasattr(data, "__bool__"):
@@ -2439,6 +2386,14 @@ def int_func(*data):
     if not F.isconstant(target):
         if base != 10:
             const_utils.raise_type_error("int() does not support non-constant input when 'base' is specified.")
+        if isinstance(target, Tensor):
+            tensor_shape = F.shape(target)
+            tensor_shape_len = len(tensor_shape)
+            if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
+                target = F.cast(target, mstype.int64)
+                return TensorToScalar()(target)
+            raise ValueError(f"Can not convert Tensor with more than one element to Scalar, "
+                             f"while the data's shape is : {tensor_shape}")
         return F.scalar_cast(target, mstype.int64)
     if isinstance(target, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
@@ -2462,7 +2417,15 @@ def float_func(*data):
         return 0.0
     data = data[0]
     if not F.isconstant(data):
-        return F.scalar_cast(data, mstype.float32)
+        if isinstance(data, Tensor):
+            tensor_shape = F.shape(data)
+            tensor_shape_len = len(tensor_shape)
+            if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
+                data = F.cast(data, mstype.float64)
+                return TensorToScalar()(data)
+            raise ValueError(f"Can not convert Tensor with more than one element to Scalar, "
+                             f"while the data's shape is: {tensor_shape}")
+        return F.scalar_cast(data, mstype.float64)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
             "float() does not support sparse tensor input.")
@@ -2477,23 +2440,18 @@ def list_func(*data):
     if data_len == 0:
         return F.make_list()
     data = data[0]
+    if isinstance(data, list):
+        return data
+    if isinstance(data, tuple):
+        return TupleToList()(data)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
             "list() does not support single sparse tensor input.")
-    if not isinstance(data, Tensor) and not hasattr(data, "__ms_iter__"):
-        data_type = F.typeof(data)
-        const_utils.raise_type_error(
-            str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
-    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
-        ret = mutable([], True)
-        if F.is_dynamic_sequence_element_unknown(data):
-            return ret
-    else:
-        ret = F.make_list()
-    for i in range(len(data)):
-        ret = ret + F.make_list(data[i])
+    ret = F.make_list()
+    for i in data:
+        ret = ret + F.make_list(i)
     return ret
 
 
@@ -2505,24 +2463,32 @@ def tuple_func(*data):
     if data_len == 0:
         return F.make_tuple()
     data = data[0]
+    if isinstance(data, tuple):
+        return data
+    if isinstance(data, list):
+        return ListToTuple()(data)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         raise TypeError("tuple() does not support single sparse tensor input.")
-    if not isinstance(data, Tensor) and not hasattr(data, "__ms_iter__"):
-        data_type = F.typeof(data)
-        raise TypeError(str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
-    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
-        ret = mutable((), True)
-        if F.is_dynamic_sequence_element_unknown(data):
-            return ret
-    else:
-        ret = F.make_tuple()
-    for i in range(len(data)):
-        ret = ret + F.make_tuple(data[i])
+    ret = F.make_tuple()
+    for i in data:
+        ret = ret + F.make_tuple(i)
     return ret
 
 
+def ms_zip(*data):
+    """Implementation of `tuple`."""
+    x = ()
+    for i in data:
+        if isinstance(i, Tensor):
+            if len(F.shape(i)) == 0:
+                raise TypeError("Cannot iterate over a scalar tensor.")
+            i = tuple(i)
+        x = x + (i,)
+    return composite.zip_operation(*x)
+
+
 def max_tensor(*data):
     """Get the max of tensor inputs."""
     if len(data) == 1:
@@ -2543,8 +2509,7 @@ def get_max_min_data_len(*data):
     if isinstance(data, (dict, list, tuple)):
         len_data = len(data)
     else:
-        const_utils.raise_type_error(
-            "max() or min() does not support the data type.")
+        raise TypeError("max() or min() does not support the data type.")
     return len_data
 
 
@@ -2556,8 +2521,7 @@ def get_tensor_num(data):
             tensor_shape = F.shape(input_data)
             tensor_shape_len = len(tensor_shape)
             if tensor_shape_len != 0 and not (tensor_shape_len == 1 and tensor_shape[0] == 1):
-                const_utils.raise_value_error(
-                    "The truth value of an array with more than one element is ambiguous.")
+                raise ValueError("The truth value of an array with more than one element is ambiguous.")
             tensor_num = tensor_num + 1
     return tensor_num
 
@@ -2577,9 +2541,9 @@ def check_sequence_all_variable_scalar(x, str_info):
     """Check whether x can be used in SequenceMax and SequenceMin"""
     if F.is_sequence_shape_unknown(x):
         if F.is_dynamic_sequence_element_unknown(x):
-            const_utils.raise_value_error(str_info + "() arg is an empty sequence.")
+            raise ValueError(str_info + "() arg is an empty sequence.")
         if not isinstance(x[0], (int, float)):
-            const_utils.raise_value_error(
+            raise ValueError(
                 "When the input to " + str_info + "() is dynamic length sequence, only support scalar type input")
         return True
     contain_variable_scalar = False
@@ -2591,74 +2555,53 @@ def check_sequence_all_variable_scalar(x, str_info):
     return contain_variable_scalar
 
 
-def get_data_type_str(input_data):
-    """Get the type of input."""
-    if isinstance(input_data, (int, float, bool)):
-        return "variable " + str(F.typeof(input_data))
-    return str(F.typeof(input_data))
-
-
-def check_isconstant(input_data, func_name):
-    """Check the input data of func is constant."""
-    if not F.isconstant(input_data):
-        const_utils.raise_type_error("The input of " + func_name + " only support Tensor, List, Tuple, constant Scalar,"
-                                                                   " but got " + get_data_type_str(input_data))
-
-
 def ms_max_one_element(x):
     """Implementation of `max` which inputs has only one element."""
     if isinstance(x, Tensor):
         tensor_shape = F.shape(x)
         tensor_shape_len = len(tensor_shape)
         if tensor_shape_len == 0:
-            const_utils.raise_type_error(
-                "Cannot iterate over a scalar tensor.")
+            raise TypeError("Cannot iterate over a scalar tensor.")
         if tensor_shape_len >= 2:
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
         return x.max()
     # Deal with Tensor in tuple or list
     if isinstance(x, (list, tuple)):
         if check_sequence_all_variable_scalar(x, "max"):
             return SequenceMax()(x)
         if len(x) == 0:
-            const_utils.raise_value_error("max() arg is an empty sequence.")
+            raise ValueError("max() arg is an empty sequence.")
         tensor_num = get_tensor_num(x)
-        if tensor_num == len(x):
+        if F.isconstant(tensor_num) and F.isconstant(len(x)) and tensor_num == len(x):
             return max_tensor(x)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "max() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("max(x)", {}, {"x": x})
         if exist_tensor(x):
-            const_utils.raise_type_error(
-                "max() cannot support tensor in list or tuple nested now.")
-    check_isconstant(x, "max()")
-    return max_(x)
+            raise TypeError("max() cannot support tensor in list or tuple nested now.")
+    if not isinstance(x, (int, float, bool)):
+        return F._py_interpret("max(x)", {}, {"x": x})
+    raise TypeError("The object is not iterable.")
 
 
 def ms_max(*data):
     """Implementation of `max`."""
     len_data = get_max_min_data_len(data)
-    if len_data <= 0:
-        const_utils.raise_type_error("max() requires 1 argument at least.")
+    if len_data <= 0: # pylint: disable=no-else-raise
+        raise TypeError("max() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
         return ms_max_one_element(x)
     elif len_data >= 2:
         tensor_num = get_tensor_num(data)
         # All inputs is Tensor
-        if tensor_num == len_data:
+        if F.isconstant(tensor_num) and F.isconstant(len_data) and tensor_num == len_data:
             return max_tensor(*data)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "max() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("max(data)", {}, {"data": data})
         # exist tensor in list/tuple
         if exist_tensor(data):
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
-    for input_data in data:
-        check_isconstant(input_data, "max()")
-    return max_(*data)
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
+    return F._py_interpret("max(data)", {}, {"data": data})
 
 
 def min_tensor(*data):
@@ -2694,71 +2637,62 @@ def ms_min_one_element(x):
         tensor_shape = F.shape(x)
         tensor_shape_len = len(tensor_shape)
         if tensor_shape_len == 0:
-            const_utils.raise_type_error(
-                "Cannot iterate over a scalar tensor.")
+            raise TypeError("Cannot iterate over a scalar tensor.")
         if tensor_shape_len >= 2:
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
         return x.min()
     # Deal with Tensor in tuple or list
     if isinstance(x, (list, tuple)):
         if check_sequence_all_variable_scalar(x, "min"):
             return SequenceMin()(x)
         if len(x) == 0:
-            const_utils.raise_value_error("min() arg is an empty sequence.")
+            raise ValueError("min() arg is an empty sequence.")
         tensor_num = get_tensor_num(x)
-        if tensor_num == len(x):
+        if F.isconstant(tensor_num) and F.isconstant(len(x)) and tensor_num == len(x):
             return min_tensor(x)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "min() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("min(x)", {}, {"x": x})
         if exist_tensor(x):
-            const_utils.raise_type_error(
-                "min() cannot support tensor in list or tuple nested now.")
-    check_isconstant(x, "min()")
-    return min_(x)
+            raise TypeError("min() cannot support tensor in list or tuple nested now.")
+    if not isinstance(x, (int, float, bool)):
+        return F._py_interpret("min(x)", {}, {"x": x})
+    raise TypeError("The object is not iterable.")
 
 
 def ms_min(*data):
     """Implementation of `min`."""
     len_data = get_max_min_data_len(data)
-    if len_data <= 0:
-        const_utils.raise_type_error("min() requires 1 argument at least.")
+    if len_data <= 0: # pylint: disable=no-else-raise
+        raise TypeError("min() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
         return ms_min_one_element(x)
     elif len_data >= 2:
         tensor_num = get_tensor_num(data)
         # All inputs is Tensor
-        if tensor_num == len_data:
+        if F.isconstant(tensor_num) and F.isconstant(len_data) and tensor_num == len_data:
             return min_tensor(*data)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "min() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("min(data)", {}, {"data": data})
         # exist tensor in list/tuple
         if exist_tensor(data):
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
-    for input_data in data:
-        check_isconstant(input_data, "min()")
-    return min_(*data)
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
+    return F._py_interpret("min(data)", {}, {"data": data})
 
 
 def ms_sum(*data):
     """Implementation of `sum`."""
     len_data = len(data)
     if len_data <= 0 or len_data > 2:
-        const_utils.raise_type_error("sum() requires 1 or 2 arguments.")
+        raise TypeError("sum() requires 1 or 2 arguments.")
     x = data[0]
-    if not isinstance(x, Tensor) and not hasattr(x, "__ms_iter__"):
+    if isinstance(x, (int, float, bool)):
         data_type = F.typeof(x)
-        const_utils.raise_type_error(
-            str(data_type) + " object is not iterable.")
+        raise TypeError(str(data_type) + " object is not iterable.")
     if isinstance(x, Tensor):
         tensor_shape = F.shape(x)
         if len(tensor_shape) == 0:
-            const_utils.raise_type_error(
-                "Cannot iterate over a scalar tensor.")
+            raise TypeError("Cannot iterate over a scalar tensor.")
     if isinstance(x, dict):
         x = x.keys()
     result = 0
@@ -2779,7 +2713,7 @@ def ms_len(data):
 
 def floor(x):
     """Rounds a tensor down to the closest integer element-wise."""
-    return x.__floor__()
+    return F.floor(x)
 
 
 def floor_divide(input, other):
@@ -2950,7 +2884,7 @@ def select(x, condition, y):
             input_y = F.cast(input_y, mstype.int32)
         else:
             input_y = F.cast(input_y, mstype.float32)
-    return F.select(condition, x, y)
+    return F.select(condition, x, input_y)
 
 
 def view(x, *shape):
@@ -3249,7 +3183,7 @@ def random_categorical(x, num_sample, seed=0, dtype=mstype.int64):
 @constexpr
 def empty_tensor(dtype):
     """Return empty tensor"""
-    return Tensor([], dtype)
+    return Tensor_([], dtype)
 
 
 @constexpr
@@ -3523,26 +3457,16 @@ def triu(input, diagonal=0):
 #############
 
 
-def tuple_next(xs):
-    """Next tuple."""
-    return xs[0], xs[1:]
-
-
-def tuple_hasnext(xs):
-    """Whether the tuple is empty or not."""
+def ms_hasnext(xs):
+    """Whether the input has next element"""
     return len(xs) > 0
 
 
-def list_next(xs):
-    """Next list."""
+def ms_next(xs):
+    """Get next element and res elements"""
     return xs[0], xs[1:]
 
 
-def list_hasnext(xs):
-    """Whether the list is empty or not."""
-    return len(xs) > 0
-
-
 def dict_next(xs):
     """Next array."""
     keys = xs.keys()
@@ -3551,23 +3475,7 @@ def dict_next(xs):
     for i in range(1, len(keys)):
         new_keys.append(keys[i])
         new_values.append(xs[keys[i]])
-    new_dict = {}
-    return keys[0], new_dict.fromkeys(new_keys, new_values)
-
-
-def dict_hasnext(xs):
-    """Whether the dict is empty or not."""
-    return len(xs) > 0
-
-
-def array_next(xs):
-    """Next array."""
-    return xs[0], xs[1:]
-
-
-def array_hasnext(xs):
-    """Whether the array is empty or not."""
-    return len(xs) > 0
+    return keys[0], F.make_dict(new_keys, new_values)
 
 
 def list_append(self_, list_item):
@@ -4152,7 +4060,7 @@ def expand(input, size):
     r"""
     Returns a new view of the self tensor with singleton dimensions expanded to a larger size.
     """
-    size = P.TensorToTuple()(size)
+    size = TensorToTuple()(size)
     return F.broadcast_to(input, size)
 
 
@@ -4533,3 +4441,15 @@ def outer(input, vec2):
     For details, please refer to :func:`mindspore.ops.vec2`.
     """
     return F.outer(input, vec2)
+
+def sigmoid(input):
+    r"""
+    For details, please refer to :func:`mindspore.ops.sigmoid`.
+    """
+    return F.sigmoid(input)
+
+def _getitem(data, index):
+    return multitype_ops.getitem(data, index)
+
+def _setitem(data, index, value):
+    return multitype_ops.setitem(data, index, value)

mindspore/_extends/remote/kernel_build_server.py

@@ -154,6 +154,8 @@ class AkgBuilderBase():
             messager.send_ack()
             wait_time_str = messager.get_message()
             messager.send_ack()
+            self.platform = messager.get_message()
+            messager.send_ack()
             self.create(int(process_num_str), int(wait_time_str))
         elif arg == 'AKG/ATTR':
             messager.send_ack()

mindspore/_profiler.py

@@ -0,0 +1,30 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""python profiler"""
+
+
+from mindspore._c_expression import PythonProfilerRecorder
+
+
+def ms_profile(fn):
+    def wrap_profile_function(*args, **kwargs):
+        recorder = PythonProfilerRecorder(fn.__qualname__)
+
+        recorder.record_start()
+        ret = fn(*args, **kwargs)
+        recorder.record_end()
+        return ret
+
+    return wrap_profile_function