parameters: (x, axis=None, keepdim=False, name=None)
return_statement: return out
docstring: Computes the minimum of tensor elements over the given axis
  
      Note:
          The difference between min and amin is: If there are multiple minimum elements,
          amin evenly distributes gradient between these equal values, 
          while min propagates gradient to all of them.
  
      Args:
          x(Tensor): A tensor, the data type is float32, float64, int32, int64.
          axis(int|list|tuple, optional): The axis along which the minimum is computed.
              If :attr:`None`, compute the minimum over all elements of
              `x` and return a Tensor with a single element,
              otherwise must be in the range :math:`[-x.ndim, x.ndim)`.
              If :math:`axis[i] < 0`, the axis to reduce is :math:`x.ndim + axis[i]`.
          keepdim(bool, optional): Whether to reserve the reduced dimension in the
              output Tensor. The result tensor will have one fewer dimension
              than the `x` unless :attr:`keepdim` is true, default
              value is False.
          name(str, optional): The default value is None.  Normally there is no need for 
              user to set this property.  For more information, please refer to :ref:`api_guide_Name`
  
      Returns:
          Tensor, results of minimum on the specified axis of input tensor,
          it's data type is the same as input's Tensor.
  
      Examples:
          .. code-block:: python
  
              import paddle
  
              # data_x is a Tensor with shape [2, 4]
              # the axis is a int element
              x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9],
                                    [0.1, 0.2, 0.6, 0.7]], 
                                   dtype='float64', stop_gradient=False)
              result1 = paddle.min(x)
              result1.backward()
              print(result1, x.grad) 
              #[0.1], [[0., 0., 0., 0.], [1., 0., 0., 0.]]
  
              x.clear_grad()
              result2 = paddle.min(x, axis=0)
              result2.backward()
              print(result2, x.grad) 
              #[0.1, 0.2, 0.5, 0.7], [[0., 0., 1., 0.], [1., 1., 0., 1.]]
  
              x.clear_grad()
              result3 = paddle.min(x, axis=-1)
              result3.backward()
              print(result3, x.grad) 
              #[0.2, 0.1], [[1., 0., 0., 0.], [1., 0., 0., 0.]]
  
              x.clear_grad()
              result4 = paddle.min(x, axis=1, keepdim=True)
              result4.backward()
              print(result4, x.grad) 
              #[[0.2], [0.1]], [[1., 0., 0., 0.], [1., 0., 0., 0.]]
  
              # data_y is a Tensor with shape [2, 2, 2]
              # the axis is list 
              y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]],
                                    [[5.0, 6.0], [7.0, 8.0]]],
                                   dtype='float64', stop_gradient=False)
              result5 = paddle.min(y, axis=[1, 2])
              result5.backward()
              print(result5, y.grad) 
              #[1., 5.], [[[1., 0.], [0., 0.]], [[1., 0.], [0., 0.]]]
  
              y.clear_grad()
              result6 = paddle.min(y, axis=[0, 1])
              result6.backward()
              print(result6, y.grad) 
              #[1., 2.], [[[1., 1.], [0., 0.]], [[0., 0.], [0., 0.]]]
function: def min(x, axis=None, keepdim=False, name=None):
      """
  
      Computes the minimum of tensor elements over the given axis
  
      Note:
          The difference between min and amin is: If there are multiple minimum elements,
          amin evenly distributes gradient between these equal values, 
          while min propagates gradient to all of them.
  
      Args:
          x(Tensor): A tensor, the data type is float32, float64, int32, int64.
          axis(int|list|tuple, optional): The axis along which the minimum is computed.
              If :attr:`None`, compute the minimum over all elements of
              `x` and return a Tensor with a single element,
              otherwise must be in the range :math:`[-x.ndim, x.ndim)`.
              If :math:`axis[i] < 0`, the axis to reduce is :math:`x.ndim + axis[i]`.
          keepdim(bool, optional): Whether to reserve the reduced dimension in the
              output Tensor. The result tensor will have one fewer dimension
              than the `x` unless :attr:`keepdim` is true, default
              value is False.
          name(str, optional): The default value is None.  Normally there is no need for 
              user to set this property.  For more information, please refer to :ref:`api_guide_Name`
  
      Returns:
          Tensor, results of minimum on the specified axis of input tensor,
          it's data type is the same as input's Tensor.
  
      Examples:
          .. code-block:: python
  
              import paddle
  
              # data_x is a Tensor with shape [2, 4]
              # the axis is a int element
              x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9],
                                    [0.1, 0.2, 0.6, 0.7]], 
                                   dtype='float64', stop_gradient=False)
              result1 = paddle.min(x)
              result1.backward()
              print(result1, x.grad) 
              #[0.1], [[0., 0., 0., 0.], [1., 0., 0., 0.]]
  
              x.clear_grad()
              result2 = paddle.min(x, axis=0)
              result2.backward()
              print(result2, x.grad) 
              #[0.1, 0.2, 0.5, 0.7], [[0., 0., 1., 0.], [1., 1., 0., 1.]]
  
              x.clear_grad()
              result3 = paddle.min(x, axis=-1)
              result3.backward()
              print(result3, x.grad) 
              #[0.2, 0.1], [[1., 0., 0., 0.], [1., 0., 0., 0.]]
  
              x.clear_grad()
              result4 = paddle.min(x, axis=1, keepdim=True)
              result4.backward()
              print(result4, x.grad) 
              #[[0.2], [0.1]], [[1., 0., 0., 0.], [1., 0., 0., 0.]]
  
              # data_y is a Tensor with shape [2, 2, 2]
              # the axis is list 
              y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]],
                                    [[5.0, 6.0], [7.0, 8.0]]],
                                   dtype='float64', stop_gradient=False)
              result5 = paddle.min(y, axis=[1, 2])
              result5.backward()
              print(result5, y.grad) 
              #[1., 5.], [[[1., 0.], [0., 0.]], [[1., 0.], [0., 0.]]]
  
              y.clear_grad()
              result6 = paddle.min(y, axis=[0, 1])
              result6.backward()
              print(result6, y.grad) 
              #[1., 2.], [[[1., 1.], [0., 0.]], [[0., 0.], [0., 0.]]]
      """
  
      reduce_all, axis = _get_reduce_all_value(axis)
      if in_dygraph_mode():
          return _C_ops.reduce_min(x, 'dim', axis, 'keep_dim', keepdim,
                                     'reduce_all', reduce_all)
  
      helper = LayerHelper('min', **locals())
      check_variable_and_dtype(
          x, 'x', ['float32', 'float64', 'int32', 'int64'], 'min')
  
      out = helper.create_variable_for_type_inference(
              dtype=x.dtype)
      helper.append_op(
          type='reduce_min',
          inputs={'X': x},
          outputs={'Out': out},
          attrs={
              'dim': axis,
              'keep_dim': keepdim,
              'reduce_all': reduce_all
          })
      return out
function_tokens: def min ( x , axis = None , keepdim = False , name = None ) : reduce_all , axis = _get_reduce_all_value ( axis ) if in_dygraph_mode ( ) : return _C_ops . reduce_min ( x , 'dim' , axis , 'keep_dim' , keepdim , 'reduce_all' , reduce_all ) helper = LayerHelper ( 'min' , * * locals ( ) ) check_variable_and_dtype ( x , 'x' , [ 'float32' , 'float64' , 'int32' , 'int64' ] , 'min' ) out = helper . create_variable_for_type_inference ( dtype = x . dtype ) helper . append_op ( type = 'reduce_min' , inputs = { 'X' : x } , outputs = { 'Out' : out } , attrs = { 'dim' : axis , 'keep_dim' : keepdim , 'reduce_all' : reduce_all } ) return out