reduce_any:
    description: |
        Reduces a dimension of a tensor by the "logical OR" of all elements in the dimension, by default. And also can
        reduce a dimension of `x` along the `axis`. Determine whether the dimensions of the output and input are the
        same by controlling `keep_dims`.

        Note:
            The `axis` with tensor type is only used for compatibility with older versions and is not recommended.

        Args:
            keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
                If ``False`` , don't keep these dimensions. Default: ``False`` .

        Inputs:
            - **x** (Tensor[bool]) - The input tensor. The dtype of the tensor to be reduced is bool.
            - **axis** (Union[int, tuple(int), list(int), Tensor]) - The dimensions to reduce. Default: ``()`` ,
              reduce all dimensions. Only constant value is allowed. Must be in the range [-rank(x), rank(x)).

        Outputs:
            Tensor, the dtype is bool.

            - If `axis` is ``()`` , and `keep_dims` is ``False`` ,
              the output is a 0-D tensor representing the "logical or" of all elements in the input tensor.
            - If `axis` is int, set as 2, and `keep_dims` is ``False`` ,
              the shape of output is :math:`(x_1, x_3, ..., x_R)`.
            - If `axis` is tuple(int), set as (2, 3), and `keep_dims` is ``False`` ,
              the shape of output is :math:`(x_1, x_4, ..., x_R)`.
            - If `axis` is 1-D Tensor, set as [2, 3], and `keep_dims` is ``False`` ,
              the shape of output is :math:`(x_1, x_4, ..., x_R)`.

        Raises:
            TypeError: If `keep_dims` is not a bool.
            TypeError: If `x` is not a Tensor.
            TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.

        Supported Platforms:
            ``Ascend`` ``GPU`` ``CPU``

        Examples:
            >>> import numpy as np
            >>> from mindspore import Tensor, ops
            >>> x = Tensor(np.array([[True, False], [True, True]]))
            >>> op = ops.ReduceAny(keep_dims=True)
            >>> # case 1: Reduces a dimension by the "logical OR" of all elements in the dimension.
            >>> output = op(x)
            >>> print(output)
            [[ True]]
            >>> print(output.shape)
            (1, 1)
            >>> # case 2: Reduces a dimension along axis 0.
            >>> output = op(x, 0)
            >>> print(output)
            [[ True True]]
            >>> # case 3: Reduces a dimension along axis 1.
            >>> output = op(x, 1)
            >>> print(output)
            [[True]
            [ True]]
            >>> # case 4: input is a scalar.
            >>> x = Tensor(True)
            >>> op = ops.ReduceAny()
            >>> output = op(x)
            >>> print(output)
            True