mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/_op_impl/aicpu/strided_slice_v2.py

@@ -1,93 +0,0 @@
-# Copyright 2022 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.
-# ============================================================================
-
-"""StridedSliceV2 op"""
-from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
-
-strided_slice_v2_op_info = AiCPURegOp("StridedSliceV2") \
-    .fusion_type("OPAQUE") \
-    .input(0, "x", "required") \
-    .input(1, "begin", "required") \
-    .input(2, "end", "required") \
-    .input(3, "strides", "required") \
-    .output(0, "output", "required") \
-    .attr("begin_mask", "int") \
-    .attr("end_mask", "int") \
-    .attr("ellipsis_mask", "int") \
-    .attr("new_axis_mask", "int") \
-    .attr("shrink_axis_mask", "int") \
-    .dtype_format(DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.BOOL_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.I8_Default) \
-    .dtype_format(DataType.I16_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.I16_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.I32_Default) \
-    .dtype_format(DataType.I64_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U8_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.U8_Default) \
-    .dtype_format(DataType.U16_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.U16_Default) \
-    .dtype_format(DataType.U32_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.U32_Default) \
-    .dtype_format(DataType.U64_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.U64_Default) \
-    .dtype_format(DataType.F16_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.F16_Default) \
-    .dtype_format(DataType.F32_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.F32_Default) \
-    .dtype_format(DataType.F64_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.F64_Default) \
-    .dtype_format(DataType.C64_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.C64_Default) \
-    .dtype_format(DataType.C128_Default, DataType.I64_Default, DataType.I64_Default,
-                  DataType.I64_Default, DataType.C128_Default) \
-    .dtype_format(DataType.BOOL_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.BOOL_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I8_Default) \
-    .dtype_format(DataType.I16_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I16_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default) \
-    .dtype_format(DataType.I64_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.U8_Default) \
-    .dtype_format(DataType.U16_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.U16_Default) \
-    .dtype_format(DataType.U32_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.U32_Default) \
-    .dtype_format(DataType.U64_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.U64_Default) \
-    .dtype_format(DataType.F16_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.F16_Default) \
-    .dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.F64_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.F64_Default) \
-    .dtype_format(DataType.C64_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.C64_Default) \
-    .dtype_format(DataType.C128_Default, DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.C128_Default) \
-    .get_op_info()
-
-
-@op_info_register(strided_slice_v2_op_info)
-def _strided_slice_v2_aicpu():
-    """StridedSliceV2 AiCPU register"""
-    return

mindspore/ops/_op_impl/aicpu/strided_slice_v2_grad.py

@@ -1,66 +0,0 @@
-# Copyright 2022 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.
-# ============================================================================
-
-"""StridedSliceGradV2 op"""
-from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
-
-strided_slice_v2_grad_op_info = AiCPURegOp("StridedSliceV2Grad") \
-    .fusion_type("OPAQUE") \
-    .input(0, "shapex", "required") \
-    .input(1, "begin", "required") \
-    .input(2, "end", "required") \
-    .input(3, "strides", "required") \
-    .input(4, "dy", "required") \
-    .output(0, "output", "required") \
-    .attr("begin_mask", "int") \
-    .attr("end_mask", "int") \
-    .attr("ellipsis_mask", "int") \
-    .attr("new_axis_mask", "int") \
-    .attr("shrink_axis_mask", "int") \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.BOOL_Default, DataType.BOOL_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.I8_Default, DataType.I8_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.I16_Default, DataType.I16_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.I64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.U8_Default, DataType.U8_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.U16_Default, DataType.U16_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.U32_Default, DataType.U32_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.U64_Default, DataType.U64_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.F16_Default, DataType.F16_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.F32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.F64_Default, DataType.F64_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.C64_Default, DataType.C64_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default,
-                  DataType.I32_Default, DataType.I32_Default, DataType.C128_Default, DataType.C128_Default) \
-    .get_op_info()
-
-
-@op_info_register(strided_slice_v2_grad_op_info)
-def _strided_slice_v2_grad_aicpu():
-    """StridedSliceV2Grad AiCPU register"""
-    return

mindspore/ops/extend/__init__.py

@@ -1,53 +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.
-# ============================================================================
-
-"""
-
-Operators with better performance
-
-"""
-
-from __future__ import absolute_import
-
-from mindspore.common import Tensor
-from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register
-from mindspore.ops.vm_impl_registry import get_vm_impl_fn, vm_impl_registry
-from mindspore.ops.op_info_register import op_info_register, custom_info_register, AkgGpuRegOp, AkgAscendRegOp, \
-    AiCPURegOp, TBERegOp, CpuRegOp, CustomRegOp, DataType
-from mindspore.ops.primitive import constexpr
-from . import (
-    array_func,
-    math_func,
-    nn_func,
-)
-
-from .array_func import gather, max, min, one_hot
-from .math_func import (
-    baddbmm,
-    bmm,
-    add,
-    sub
-)
-
-from .nn_func import (
-    conv2d,
-    max_pool2d,
-    leaky_relu_ext
-)
-
-__all__ = []
-__all__.extend(array_func.__all__)
-__all__.extend(math_func.__all__)
-__all__.extend(nn_func.__all__)

mindspore/ops/extend/array_func.py

@@ -1,218 +0,0 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-"""
-
-Array Operators
-
-"""
-from mindspore.common import Tensor
-from mindspore.ops.operations.array_ops import ArgMaxWithValue, ArgMinWithValue
-from mindspore.ops._primitive_cache import _get_cache_prim
-from mindspore.ops.auto_generate.gen_ops_prim import gather_d_op
-from mindspore.ops.auto_generate.gen_ops_def import max_, min_
-from mindspore.ops.auto_generate.pyboost_inner_prim import _PyboostOneHotExtPrim
-one_hot_ext_impl = _PyboostOneHotExtPrim()
-
-# define Primitive global variables
-
-def gather(input, dim, index):
-    r"""
-    Gather data from a tensor by indices.
-
-    .. math::
-        output[(i_0, i_1, ..., i_{dim}, i_{dim+1}, ..., i_n)] =
-        input[(i_0, i_1, ..., index[(i_0, i_1, ..., i_{dim}, i_{dim+1}, ..., i_n)], i_{dim+1}, ..., i_n)]
-
-    .. warning::
-        On Ascend, the behavior is unpredictable in the following cases:
-
-        - the value of `index` is not in the range `[-input.shape[dim], input.shape[dim])` in forward;
-        - the value of `index` is not in the range `[0, input.shape[dim])` in backward.
-
-    Args:
-        input (Tensor): The target tensor to gather values.
-        dim (int): the axis to index along, must be in range `[-input.rank, input.rank)`.
-        index (Tensor): The index tensor, with int32 or int64 data type. An valid `index` should be:
-
-            - `index.rank == input.rank`;
-            - for `axis != dim`, `index.shape[axis] <= input.shape[axis]`;
-            - the value of `index` is in range `[-input.shape[dim], input.shape[dim])`.
-
-    Returns:
-        Tensor, has the same type as `input` and the same shape as `index`.
-
-    Raises:
-        ValueError: If the shape of `index` is illegal.
-        ValueError: If `dim` is not in `[-input.rank, input.rank)`.
-        ValueError: If the value of `index` is out of the valid range.
-        TypeError: If the type of `index` is illegal.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
-        >>> index = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
-        >>> output = ops.extend.gather(input, 1, index)
-        >>> print(output)
-        [[-0.1 -0.1]
-         [0.5   0.5]]
-    """
-    return gather_d_op(input, dim, index)
-
-
-def max(input, dim=None, keepdim=False):
-    """
-    Calculates the maximum value along with the given dimension for the input tensor.
-
-    Args:
-        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
-        dim (int, optional): The dimension to reduce. Default: ``None`` .
-        keepdim (bool, optional): Whether to reduce dimension, if true, the output will keep same dimension
-            with the input, the output will reduce dimension if false. Default: ``False`` .
-
-    Returns:
-        Tensor if `dim` is the default value ``None`` , the maximum value of input tensor, with the shape :math:`()` ,
-        and same dtype as `input`.
-
-        tuple (Tensor) if `dim` is not the default value ``None`` , tuple of 2 tensors, containing the maximum
-        value of the input tensor along the given dimension `dim` and the corresponding index.
-
-        - **values (Tensor)** - The maximum value of input tensor along the given dimension `dim`, with same dtype as
-          `input`. If `keepdim` is ``True`` , the shape of output tensors is :math:`(input_1, input_2, ...,
-          input_{axis-1}, 1, input_{axis+1}, ..., input_N)` . Otherwise, the shape is :math:`(input_1, input_2, ...,
-          input_{axis-1}, input_{axis+1}, ..., input_N)` .
-        - **index (Tensor)** - The index for the maximum value of the input tensor along the given dimension `dim`, with
-          the same shape as `values`.
-
-    Raises:
-        ValueError: If `dim` is the default value ``None`` and `keepdim` is not ``False`` .
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> y = Tensor(np.array([[0.0, 0.3, 0.4, 0.5, 0.1],
-        ...                      [3.2, 0.4, 0.1, 2.9, 4.0]]), mindspore.float32)
-        >>> output, index = ops.extend.max(y, 0, True)
-        >>> print(output, index)
-        [[3.2 0.4 0.4 2.9 4. ]] [[1 1 0 1 1]]
-    """
-    if dim is None:
-        if keepdim is not False:
-            raise ValueError(f"For 'max', the `keepdim` must be False when the `dim` is None, but got {keepdim}")
-        return max_(input)
-    argmax_with_value_op = _get_cache_prim(ArgMaxWithValue)(dim, keepdim)
-    indices, values = argmax_with_value_op(input)
-    return values, indices
-
-
-def min(input, dim=None, keepdim=False):
-    """
-    Calculates the minimum value along with the given dimension for the input tensor.
-
-    Args:
-        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
-        dim (int, optional): The dimension to reduce. Default: ``None`` .
-        keepdim (bool, optional): Whether to reduce dimension, if true, the output will keep same dimension
-            with the input, the output will reduce dimension if false. Default: ``False`` .
-
-    Returns:
-        Tensor if `dim` is the default value ``None`` , the minimum value of input tensor, with the shape :math:`()` ,
-        and same dtype as `input`.
-
-        tuple (Tensor) if `dim` is not the default value ``None`` , tuple of 2 tensors, containing the minimum value
-        of the input tensor along the given dimension `dim` and the corresponding index.
-
-        - **values (Tensor)** - The minimum value of input tensor along the given dimension `dim`, with same dtype as
-          `input`. If `keepdim` is ``True`` , the shape of output tensors is :math:`(input_1, input_2, ...,
-          input_{axis-1}, 1, input_{axis+1}, ..., input_N)` . Otherwise, the shape is :math:`(input_1, input_2, ...,
-          input_{axis-1}, input_{axis+1}, ..., input_N)` .
-        - **index (Tensor)** - The index for the minimum value of the input tensor along the given dimension `dim`,
-          with the same shape as `values`.
-
-    Raises:
-        ValueError: If `dim` is the default value ``None`` and `keepdim` is not ``False`` .
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-        >>> output, index = ops.extend.min(x, 0, keepdim=True)
-        >>> print(output, index)
-        [0.0] [0]
-    """
-    if dim is None:
-        if keepdim is not False:
-            raise ValueError(f"For 'min', the `keepdim` must be False when the `dim` is None, but got {keepdim}")
-        return min_(input)
-    argmin_with_value_op = _get_cache_prim(ArgMinWithValue)(dim, keepdim)
-    indices, values = argmin_with_value_op(input)
-    return values, indices
-
-
-def one_hot(tensor, num_classes):
-    r"""
-    Computes a one-hot tensor.
-
-    The locations represented by tensor in `tensor` take value `1`, while all
-    other locations take value `0`.
-
-    Args:
-        tensor (Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
-            Data type must be int32 or int64.
-        num_classes (int): A scalar defining the depth of the one-hot dimension.
-
-    Returns:
-        Tensor, one-hot tensor.
-
-    Raises:
-        TypeError: If `num_classes` is not an int.
-        TypeError: If dtype of `tensor` is not int32 or int64.
-        ValueError: If `num_classes` is less than 0.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import ops
-        >>> from mindspore import Tensor
-        >>> tensor = Tensor(np.array([0, 1, 2]), mindspore.int32)
-        >>> num_classes = 3
-        >>> output = ops.extend.one_hot(tensor, num_classes)
-        >>> print(output)
-        [[1. 0. 0.]
-        [0. 1. 0.]
-        [0. 0. 1.]]
-    """
-    on_value = Tensor(1, dtype=tensor.dtype)
-    off_value = Tensor(0, dtype=tensor.dtype)
-    return one_hot_ext_impl(tensor, num_classes, on_value, off_value, -1)
-
-
-__all__ = ['gather', 'max', 'min', 'one_hot']

mindspore/ops/extend/math_func.py

@@ -1,76 +0,0 @@
-# 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.
-# ============================================================================
-
-"""
-
-Math Operators with better performance
-
-"""
-
-from mindspore.ops import auto_generate as P
-from mindspore.ops.auto_generate.gen_ops_def import add_ext as add, sub_ext as sub, bmm_ext as bmm
-
-
-# define Primitive global variables
-
-
-def baddbmm(input, batch1, batch2, beta=1, alpha=1):
-    r"""
-    The result is the sum of the input and a batch matrix-matrix product of matrices in batch1 and batch2.
-    The formula is defined as follows:
-
-    .. math::
-        \text{out}_{i} = \beta \text{input}_{i} + \alpha (\text{batch1}_{i} \mathbin{@} \text{batch2}_{i})
-
-    Args:
-        input (Tensor): The input Tensor. When batch1 is a :math:`(C, W, T)` Tensor and batch2 is a
-            :math:`(C, T, H)` Tensor, input must be broadcastable with :math:`(C, W, H)` Tensor.
-        batch1 (Tensor): :math:`batch1` in the above formula. Must be 3-D Tensor, dtype is same as input.
-        batch2 (Tensor): :math:`batch2` in the above formula. Must be 3-D Tensor, dtype is same as input.
-        beta (Union[float, int], optional): multiplier for input. Default: ``1`` .
-        alpha (Union[float, int], optional): multiplier for :math:`batch1 @ batch2`. Default: ``1`` .
-            Arguments beta and alpha must be integers when inputs of type not FloatTensor, otherwise they should
-            be a real number.
-
-    Returns:
-        Tensor, has the same dtype as input, shape will be :math:`(C, W, H)`.
-
-    Raises:
-        TypeError: The type of `input`, `batch1`, `batch2` is not Tensor.
-        TypeError: The types of `input`, `batch1`, `batch2` are different.
-        TypeError: For inputs of type FloatTensor or DoubleTensor, \
-                    arguments beta and alpha not be real numbers, otherwise not be integers.
-        TypeError: For Baddbmm, attributes alpha and beta are not real numbers
-        ValueError: If `batch1` and `batch2` are not 3-D tensors.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.ones([1, 3, 3]).astype(np.float32))
-        >>> batch1 = Tensor(np.ones([1, 3, 4]).astype(np.float32))
-        >>> batch2 = Tensor(np.ones([1, 4, 3]).astype(np.float32))
-        >>> output = ops.baddbmm(input, batch1, batch2)
-        >>> print(output)
-        [[[5. 5. 5.]
-          [5. 5. 5.]
-          [5. 5. 5.]]]
-    """
-    return P.baddbmm(input, batch1, batch2, beta, alpha)
-
-
-__all__ = ['baddbmm', 'add', 'sub', 'bmm']