mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/ops/composite/base.py

@@ -782,7 +782,7 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
         if len(self.entries) == 1:
             output = self.entries[0][1](*args)
             return output
-        types = tuple(map(mstype._get_py_obj_dtype, args))  # pylint:disable=protected-access
+        types = tuple(map(mstype.get_py_obj_dtype, args))
         for sigs, fn in self.entries:
             if len(sigs) != len(types):
                 continue

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -619,7 +619,7 @@ def scalar_in_sequence(x, y):
 @constexpr
 def get_np_eps(input_dtype):
     """Get numpy eps."""
-    nptype = mstype._dtype_to_nptype(input_dtype)  # pylint:disable=protected-access
+    nptype = mstype.dtype_to_nptype(input_dtype)
     eps = np.finfo(nptype).eps
     return float(eps)
 

mindspore/ops/function/__init__.py

@@ -481,7 +481,6 @@ from .nn_func import (
     max_pool3d,
     moe_token_permute,
     moe_token_unpermute,
-    ring_attention_update,
     batch_norm,
     add_rms_norm,
     rms_norm,

mindspore/ops/function/array_func.py

@@ -784,7 +784,7 @@ def full_ext(size, fill_value, *, dtype=None):  # pylint: disable=redefined-oute
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The specified type of output tensor.
-            `bool` and `number` are supported, for details,
+            `bool_` and `number` are supported, for details,
             please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
     Returns:
@@ -857,7 +857,7 @@ def full_like_ext(input, fill_value, *, dtype=None):
         fill_value (Number): Value to fill the returned tensor. Complex numbers are not supported for now.
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The specified type of output tensor. `bool` and `number` are supported,
+        dtype (mindspore.dtype, optional): The specified type of output tensor. `bool_` and `number` are supported,
             for details, please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
     Returns:
@@ -4728,11 +4728,7 @@ def _tensor_split_sub_tensors(x, indices_or_sections, axis):
         idx = indices_or_sections[i]
         begin[axis] = 0 if i == 0 else indices_or_sections[i - 1]
         end[axis] = idx
-        if begin[axis] == end[axis]:
-            empty_shape = x.shape[0:axis] + (0,) + x.shape[axis + 1:]
-            sliced_tensor = ms.Tensor(shape=empty_shape, dtype=x.dtype)
-        else:
-            sliced_tensor = strided_slice(x, tuple(begin), tuple(end), strides)
+        sliced_tensor = strided_slice(x, tuple(begin), tuple(end), strides)
         sub_tensors.append(sliced_tensor)
     return tuple(sub_tensors)
 
@@ -4748,7 +4744,7 @@ def _tensor_split_sub_int(x, indices_or_sections, axis):
         res = _get_cache_prim(P.Split)(axis)(x)
     elif indices_or_sections > length_along_dim:
         res = _get_cache_prim(P.Split)(axis, length_along_dim)(x)
-        indices_or_sections_n = [length_along_dim]
+        indices_or_sections_n = [length_along_dim, length_along_dim + 1]
         res2 = _tensor_split_sub_tensors(x, indices_or_sections_n, axis)
         for _ in np.arange(length_along_dim, indices_or_sections):
             res += tuple(res2)[1:]
@@ -5071,7 +5067,7 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
         >>> # case 4: Use "where" to include only specific elements in computing the maximum.
         >>> where = mindspore.tensor([[0, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
         >>> mindspore.ops.max(input, axis=1, keepdims=True, initial=0, where=where)
         (Tensor(shape=[3, 1], dtype=Int64, value=
          [[4],
@@ -5211,7 +5207,7 @@ def min(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
         >>> # case 4: Use "where" to include only specific elements in computing the minimum.
         >>> where = mindspore.tensor([[1, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
         >>> mindspore.ops.min(input, axis=1, keepdims=True, initial=0, where=where)
         (Tensor(shape=[3, 1], dtype=Int64, value=
          [[ 0],

mindspore/ops/function/debug_func.py

@@ -124,7 +124,6 @@ def tensordump(file_name, tensor, mode='out'):
             --master_port=11450 --log_dir=msrun_log --join=True --cluster_time_out=300 tensordump_example.py
 
         >>> import os
-        >>> import time
         >>> import numpy as np
         >>> import mindspore
         >>> from mindspore import nn, context
@@ -151,16 +150,15 @@ def tensordump(file_name, tensor, mode='out'):
         >>> strategy1 = ((1, 2), (2, 1))
         >>> strategy2 = ((1, 2), (2, 1))
         >>> with no_init_parameters():
-        ...     net = Net(strategy1, strategy2)
+        >>>     net = Net(strategy1, strategy2)
         >>> x = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
         >>> y = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
         >>> b = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
-        >>> parallel_net = AutoParallel(net, parallel_mode="semi_auto")
+        >>> parallel_net = Autoparallel(net, parallel_mode="semi_auto")
         >>> parallel_net.dataset_strategy(config="full_batch")
         >>> out = parallel_net(x, y, b)
         >>> print(f"out shape is: {out.shape}")
         >>> # out shape is (64, 64)
-        >>> time.sleep(0.5) # npy file is generated asynchronously, spend an interval time then load it.
         >>> matmul1_output_slice = np.load(f'rank_{rank_id}_mul1_mul2_float32_0.npy')      # load matmul1's output slice
         >>> print(f"matmul1_output_slice is loaded, shape is: {matmul1_output_slice.shape}")
         >>> # matmul1_output_slice is loaded, shape is: (64, 64)

mindspore/ops/function/grad/grad_func.py

@@ -654,7 +654,9 @@ def _check_jvp_input_v_len(inputs_len, v_len):
 
 def jvp(fn, inputs, v, has_aux=False):
     """
-    Compute the jacobian-vector-product of the given network.
+    Compute the jacobian-vector-product of the given network. The calculation procedure of JVP can be found in
+    `forward-mode differentiation
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -867,7 +869,9 @@ _vjp_grad_op_with_weight = _Grad(get_all=True, get_by_list=True, sens_param=True
 
 def vjp(fn, *inputs, weights=None, has_aux=False):
     """
-    Compute the vector-jacobian-product of the given network.
+    Compute the vector-jacobian-product of the given network. `vjp` matches
+    `reverse-mode differentiation
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -1066,7 +1070,9 @@ _vmap = _Vmap()
 
 def jacfwd(fn, grad_position=0, has_aux=False):
     """
-    Compute Jacobian via forward mode.
+    Compute Jacobian via forward mode, corresponding to
+    `forward-mode differentiation
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
     When number of outputs is much greater than that of inputs, it's better to calculate Jacobian via forward mode than
     reverse mode to get better performance.
 
@@ -1235,7 +1241,9 @@ _grad = _Grad(get_by_position=True, has_aux=False, sens_param=True)
 
 def jacrev(fn, grad_position=0, has_aux=False):
     """
-    Compute Jacobian via reverse mode.
+    Compute Jacobian via reverse mode, corresponding to
+    `reverse-mode differentiation
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
     When number of inputs is much greater than that of outputs, it's better to calculate Jacobian via reverse mode than
     forward mode to get better performance.
 

mindspore/ops/function/math_func.py

@@ -1218,7 +1218,7 @@ def logical_not(input):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
         >>> output = mindspore.ops.logical_not(x)
         >>> print(output)
         [False  True False]
@@ -1250,23 +1250,23 @@ def logical_or(input, other):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
-        >>> y = mindspore.tensor([True, True, False], mindspore.bool)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
+        >>> y = mindspore.tensor([True, True, False], mindspore.bool_)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         [ True  True  True]
-        >>> x = mindspore.tensor(1, mindspore.bool)
-        >>> y = mindspore.tensor(0, mindspore.bool)
+        >>> x = mindspore.tensor(1, mindspore.bool_)
+        >>> y = mindspore.tensor(0, mindspore.bool_)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor(0, mindspore.bool)
+        >>> y = mindspore.tensor(0, mindspore.bool_)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor([True, False], mindspore.bool)
+        >>> y = mindspore.tensor([True, False], mindspore.bool_)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         [True True]
@@ -1298,23 +1298,23 @@ def logical_and(input, other):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
-        >>> y = mindspore.tensor([True, True, False], mindspore.bool)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
+        >>> y = mindspore.tensor([True, True, False], mindspore.bool_)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         [ True False False]
-        >>> x = mindspore.tensor(1, mindspore.bool)
-        >>> y = mindspore.tensor(0, mindspore.bool)
+        >>> x = mindspore.tensor(1, mindspore.bool_)
+        >>> y = mindspore.tensor(0, mindspore.bool_)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         False
         >>> x = True
-        >>> y = mindspore.tensor(0, mindspore.bool)
+        >>> y = mindspore.tensor(0, mindspore.bool_)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         False
         >>> x = True
-        >>> y = mindspore.tensor([True, False], mindspore.bool)
+        >>> y = mindspore.tensor([True, False], mindspore.bool_)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         [True False]
@@ -1782,10 +1782,10 @@ def pow_ext(input, exponent):
     Args:
         input (Union[Tensor, Number]): The first input is a Number or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         exponent (Union[Tensor, Number]): The second input is a Number or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,
@@ -5149,18 +5149,6 @@ def bernoulli_ext(input, *, generator=None):
     return bernoulli_ext_(input, seed, offset)
 
 
-def bernoulli_(input, p=0.5, *, generator=None):
-    r"""
-    bernoulli_(input, p=0.5, *, generator=None) -> Tensor
-
-    In-place version of :func:`mindspore.ops.bernoulli_ext`.
-    """
-    if generator is None:
-        generator = default_generator
-    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
-    return ops.functional_overload.bernoulli_(input, p, seed, offset)
-
-
 def bessel_i1(x):
     r"""
     Computes the first order modified Bessel function of the first kind for each element input.
@@ -6637,7 +6625,7 @@ def amin(input, axis=None, keepdims=False, *, initial=None, where=None):
         >>> # case 4: Use "where" to include only specific elements in computing the minimum.
         >>> where = mindspore.tensor([[1, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
         >>> mindspore.ops.amin(input, axis=1, keepdims=True, initial=0, where=where)
         Tensor(shape=[3, 1], dtype=Int64, value=
          [[ 0],
@@ -6719,7 +6707,7 @@ def amax(input, axis=None, keepdims=False, *, initial=None, where=None):
         >>> # case 4: Use "where" to include only specific elements in computing the maximum.
         >>> where = mindspore.tensor([[0, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
         >>> mindspore.ops.amax(input, axis=1, keepdims=True, initial=0, where=where)
         Tensor(shape=[3, 1], dtype=Int64, value=
         [[4],
@@ -9172,10 +9160,10 @@ def remainder_ext(input, other):
         input (Union[Tensor, numbers.Number, bool]): The dividend is a numbers.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, numbers.Number, bool]): The divisor is a numbers.Number or
-            a bool or a tensor whose data type is number or bool when the dividend is a tensor.
-            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool.
+            a bool or a tensor whose data type is number or bool\_ when the dividend is a tensor.
+            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool\_.
 
     Returns:
         Tensor, with dtype promoted and shape broadcasted.
@@ -10189,23 +10177,23 @@ def logical_xor(input, other):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
-        >>> y = mindspore.tensor([True, True, False], mindspore.bool)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
+        >>> y = mindspore.tensor([True, True, False], mindspore.bool_)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         [False  True  True]
-        >>> x = mindspore.tensor(1, mindspore.bool)
-        >>> y = mindspore.tensor(0, mindspore.bool)
+        >>> x = mindspore.tensor(1, mindspore.bool_)
+        >>> y = mindspore.tensor(0, mindspore.bool_)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor(0, mindspore.bool)
+        >>> y = mindspore.tensor(0, mindspore.bool_)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor([True, False], mindspore.bool)
+        >>> y = mindspore.tensor([True, False], mindspore.bool_)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         [False  True]
@@ -10664,7 +10652,7 @@ def _canonicalize_fft_shape_and_dim(input, shape, dim):
 
 
 def as_strided(x, shape=None, strides=None):
-    n = np.dtype(mstype._dtype_to_nptype(x.dtype)).itemsize  # pylint:disable=protected-access
+    n = np.dtype(mstype.dtype_to_nptype(x.dtype)).itemsize
     strides = tuple(np.array(strides) * n)
     if x.dtype == mstype.bfloat16:
         return Tensor(np.lib.stride_tricks.as_strided(x.float().asnumpy(), shape, strides, False, True), dtype=x.dtype)
@@ -10715,7 +10703,7 @@ def _permute_input(input, input_dim, ret_dim):
         (dim_permute_a if not is_transformed_dim[i] else dim_permute_b).append(value)
 
     # strides
-    type_size = np.dtype(mstype._dtype_to_nptype(input.dtype)).itemsize  # pylint:disable=protected-access
+    type_size = np.dtype(mstype.dtype_to_nptype(input.dtype)).itemsize
     input_strides = [int(x / type_size) for x in input.strides]
 
     def cmp(x, y):
@@ -10828,7 +10816,7 @@ def _handle_fftwithsize_output(out, input_dim, batch_dims, dim_permute, out_size
     for i in range(batch_dims, input_dim):
         out_strides[dim_permute[i]] = out.strides[1 + (i - batch_dims)]
 
-    type_size = np.dtype(mstype._dtype_to_nptype(out.dtype)).itemsize  # pylint:disable=protected-access
+    type_size = np.dtype(mstype.dtype_to_nptype(out.dtype)).itemsize
     if out.shape != out_sizes or out.strides != out_strides:
         out = as_strided(out, out_sizes, [int(i / type_size) for i in out_strides])
     return out
@@ -11206,7 +11194,7 @@ def count_nonzero(x, axis=(), keep_dims=False, dtype=mstype.int32):
             Default ``()`` , which counts all non-zero elements.
         keep_dims (bool, optional): Whether to maintain dimensions specified by `axis`.
             Default ``False`` , don't keep these dimensions.
-        dtype (Union[Number, mindspore.bool], optional): The data type returned.
+        dtype (Union[Number, mindspore.bool\_], optional): The data type returned.
             Default ``mstype.int32`` .
 
 
@@ -12095,11 +12083,11 @@ def mul_ext(input, other):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,

mindspore/ops/function/nn_func.py

@@ -41,7 +41,7 @@ from mindspore.ops.operations.nn_ops import TripletMarginLoss
 from mindspore.ops.operations._sequence_ops import TupleToTensor, TensorToTuple, ListToTensor
 from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import log_softmax, dense, prelu, celu, fast_gelu, silu, elu, sigmoid, relu6, \
-    softmax_impl, swiglu, logsigmoid_op, kl_div_op, divs_op, l1_loss_ext
+    softmax_impl, swiglu, logsigmoid_op, kl_div_op, divs_op
 from mindspore.ops.auto_generate import relu_op, inplace_relu_op
 from mindspore.ops.auto_generate import group_norm_op, rms_norm, add_rms_norm, layer_norm_ext_op, batch_norm_ext_op,\
     mse_loss_ext
@@ -49,7 +49,7 @@ from mindspore.ops.auto_generate import group_norm_op, rms_norm, add_rms_norm, l
 from mindspore.ops.auto_generate import (reflection_pad_1d_op, reflection_pad_2d_op, add_layernorm_v2_op,
                                          reflection_pad_3d_op,  # pylint: disable=W0611
                                          replication_pad_1d_op, replication_pad_2d_op, replication_pad_3d_op,
-                                         constant_pad_nd_op, func_dropout_ext_op, reverse_v2_impl, avg_pool2d_op,
+                                         constant_pad_nd_op, dropout_ext_op, reverse_v2_impl, avg_pool2d_op,
                                          upsample_nearest1d_op, upsample_nearest2d_op, upsample_nearest3d_op,
                                          upsample_linear1d_op, upsample_bilinear2d_op, upsample_bicubic2d_op,
                                          upsample_trilinear3d_impl, fill_scalar_op, floor_op, nllloss_2d_op,
@@ -101,7 +101,7 @@ from mindspore.common.generator import default_generator
 from mindspore.ops.auto_generate import hardshrink, hardsigmoid, hardswish
 from mindspore.ops.auto_generate import softshrink
 from mindspore.ops.auto_generate import soft_margin_loss
-from mindspore.ops.auto_generate import moe_token_permute, moe_token_unpermute, ring_attention_update
+from mindspore.ops.auto_generate import moe_token_permute, moe_token_unpermute
 from mindspore.ops.auto_generate import adaptive_avg_pool2d_ext_op
 from mindspore.ops.auto_generate.pyboost_inner_prim import nllloss_impl
 from mindspore.ops.auto_generate.pyboost_inner_prim import adaptive_max_pool2d_impl
@@ -1623,6 +1623,7 @@ def dropout_ext(input, p=0.5, training=True, inplace=False):
         - **output** (Tensor) - Zeroed tensor, with the same shape and data type as `input`.
 
     Raises:
+        TypeError: If `p` is not a float.
         TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
@@ -1636,8 +1637,16 @@ def dropout_ext(input, p=0.5, training=True, inplace=False):
         >>> print(output.shape)
         (2, 2)
     """
+    check_bool_const(training, "training", "dropout_ext")
+    check_bool_const(inplace, "inplace", "dropout_ext")
+    if not training:
+        return input
     seed, offset = default_generator._step(generator_step_)  # pylint: disable=protected-access
-    return func_dropout_ext_op(input, p, training, inplace, seed, offset)
+    out, _ = dropout_ext_op(input, p, seed, offset)
+    if inplace:
+        input.copy_(out)
+        return input
+    return out
 
 
 def dropout1d(input, p=0.5, training=True):
@@ -2386,7 +2395,7 @@ def is_floating_point(input):
         >>> mindspore.ops.is_floating_point(input)
         False
     """
-    return input.dtype in mstype.float_type
+    return input.dtype in [mstype.float32, mstype.bfloat16, mstype.float16, mstype.float64]
 
 
 def _is_dim_unknown(shape):
@@ -4294,15 +4303,6 @@ def nll_loss(inputs, target, weight=None, ignore_index=-100, reduction='mean', l
         \sum_{n=1}^{N} l_{n}, & \text { if reduction }=\text { 'sum' }
         \end{array}\right.
 
-    .. warning::
-        - In GE mode, the rank of `inputs` should be 1D or 2D, the rank of `target` and `weight` should be 1D,
-          and the following restraints should be met:
-
-          - when `inputs` is 1D: target_shape[0] == 1 and weight_shape[0] == inputs_shape[0].
-          - when `inputs` is 2D: target_shape[0] == inputs_shape[0] and weight_shape[0] == inputs_shape[1].
-
-        - On GPU or CPU, `inputs` should be 2D.
-
     Args:
         inputs (Tensor): :math:`(N, C)` where `C = number of classes` or :math:`(N, C, H, W)`
             in case of 2D Loss, or :math:`(N, C, d_1, d_2, ..., d_K)`.
@@ -4846,9 +4846,8 @@ def smooth_l1_loss(input, target, beta=1.0, reduction='none'):
         >>> print(output)
         [0.  0.  0.5]
     """
-    if beta == 0.0:
-        return l1_loss_ext(input, target, reduction)
-    return ops.auto_generate.smooth_l1_loss(input, target, beta=beta, reduction=reduction)
+    _smooth_l1_loss = _get_cache_prim(P.SmoothL1Loss)(beta, reduction)
+    return _smooth_l1_loss(input, target)
 
 
 def threshold(input, thr, value):
@@ -6439,6 +6438,9 @@ def conv2d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
     <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_ and
     `ConvNets <http://cs231n.github.io/convolutional-networks/>`_.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         input (Tensor): Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` or :math:`(C_{in}, H_{in}, W_{in})`.
         weight (Tensor): Tensor of shape
@@ -7390,6 +7392,7 @@ def conv3d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
 
     .. warning::
         This API does not support Atlas series products.
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         input (Tensor): Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
@@ -9650,7 +9653,6 @@ __all__ = [
     'lp_pool2d',
     'moe_token_permute',
     'moe_token_unpermute',
-    'ring_attention_update',
     'max_unpool1d',
     'max_unpool2d',
     'max_unpool3d',

mindspore/ops/functional.py

@@ -20,7 +20,7 @@ from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
 from mindspore.ops.function.array_func import chunk_ext, zero_
-from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_, bernoulli_ext, bernoulli_
+from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_, bernoulli_ext
 from mindspore.ops.function.random_func import random_, uniform_ext, uniform_, normal_, exponential_
 from mindspore.ops import operations as P
 from mindspore.ops.operations import array_ops
@@ -397,7 +397,6 @@ setattr(tensor_operator_registry, 'inplace_scatter_add', auto_generate.inplace_s
 setattr(tensor_operator_registry, 'slice_scatter', slice_scatter)
 setattr(tensor_operator_registry, 'select_scatter', select_scatter)
 setattr(tensor_operator_registry, 'bernoulli', bernoulli_ext)
-setattr(tensor_operator_registry, 'bernoulli_', bernoulli_)
 setattr(tensor_operator_registry, 'poisson', P.Poisson)
 setattr(tensor_operator_registry, 'randperm', P.Randperm)
 setattr(tensor_operator_registry, 'multinomial', multinomial)

mindspore/ops/functional_overload.py

@@ -17,7 +17,6 @@ from mindspore._c_expression import _add_instance
 from mindspore._c_expression import _addcdiv_instance
 from mindspore._c_expression import _all_gather_matmul_instance
 from mindspore._c_expression import _any_instance
-from mindspore._c_expression import _bernoulli__instance
 from mindspore._c_expression import _bitwise_not_instance
 from mindspore._c_expression import _clamp_instance
 from mindspore._c_expression import _conv3d_instance
@@ -67,10 +66,10 @@ def add(*args, **kwargs):
     Args:
         input (Union[Tensor, number.Number, bool]): `input` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): `other` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Keyword Args:
         alpha (number.Number, optional): A scaling factor applied to `other`, default ``1``.
@@ -318,15 +317,6 @@ def any(*args, **kwargs):
     return _any_instance(*args, **kwargs)
 
 
-def bernoulli_(*args, **kwargs):
-    r"""
-    bernoulli_(input, p, seed, offset) -> Tensor
-
-    Inner function, used for Tensor.bernoulli_.
-    """
-    return _bernoulli__instance(*args, **kwargs)
-
-
 def bitwise_not(*args, **kwargs):
     r"""
     bitwise_not(input) -> Tensor
@@ -589,7 +579,7 @@ def div(*args, **kwargs):
     .. note::
         - When the two inputs have different shapes, they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
+          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
         - The two inputs comply with the implicit type conversion rules to make the data types
           consistent.
 
@@ -1117,10 +1107,10 @@ def greater_equal(*args, **kwargs):
 
     Args:
         input (Union[Tensor, Number]): The first input is a number
-            or a tensor whose data type is `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ or `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_.
+            or a tensor whose data type is `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ or `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_.
         other (Union[Tensor, Number]): Second input. When the first input is a Tensor, the second input should be a Number,
-            or a Tensor of the number or bool data type. When the first input is a Scalar,
-            the second input must be a Tensor of number or bool data type.
+            or a Tensor of the number or bool_ data type. When the first input is a Scalar,
+            the second input must be a Tensor of number or bool_ data type.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
@@ -1729,10 +1719,10 @@ def remainder(*args, **kwargs):
         input (Union[Tensor, numbers.Number, bool]): The dividend is a numbers.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, numbers.Number, bool]): The divisor is a numbers.Number or
-            a bool or a tensor whose data type is number or bool when the dividend is a tensor.
-            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool.
+            a bool or a tensor whose data type is number or bool\_ when the dividend is a tensor.
+            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool\_.
 
     Returns:
         Tensor, with dtype promoted and shape broadcasted.
@@ -1826,10 +1816,10 @@ def sub(*args, **kwargs):
     Args:
         input (Union[Tensor, number.Number, bool]): `input` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): `other` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Keyword Args:
         alpha (number.Number, optional): A scaling factor applied to `other`, default ``1``.
@@ -1945,7 +1935,7 @@ def xlogy(*args, **kwargs):
         input (Union[Tensor, numbers.Number, bool]): The first input is a numbers.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, numbers.Number, bool]): The second input is a numbers.Number or
             a bool or a tensor whose data type is number or bool when the first input is a tensor.
             When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
@@ -1979,7 +1969,6 @@ __all__ = [
     "addcdiv",
     "all_gather_matmul",
     "any",
-    "bernoulli_",
     "bitwise_not",
     "clamp",
     "clip",