code: def unique(data, is_sorted=True, return_counts=False):
      """Find the unique elements of a 1-D tensor. Please note `output` and `counts` are all padded to
      have the same length of `data` and element with index >= num_unique[0] has undefined value.
  
      Parameters
      ----------
      data : relay.Expr
          A 1-D tensor of integers.
  
      is_sorted : bool, optional
          Whether to sort the unique elements in ascending order before returning as output.
  
      return_counts : bool, optional
          Whether to return the count of each unique element.
  
      Returns
      -------
      unique : relay.Expr
          A 1-D tensor containing the unique elements of the input data tensor.
  
      indices : relay.Expr
          A 1-D tensor containing the indeces of the first occurence of each unique value
          in the input tensor.
  
      inverse_indices : relay.Expr
          A 1-D tensor. For each entry in data, it contains the index of that data element in the
          unique array.
  
      num_unique : relay.Expr
          A 1-D tensor with size=1 containing the number of unique elements in the input data tensor.
  
      counts : relay.Expr, optional
          A 1-D tensor containing the count of each unique element in the output.
  
      Examples
      --------
      .. code-block:: python
  
          [output, indices, inverse_indices, num_unique] = unique([4, 5, 1, 2, 3, 3, 4, 5],
                                                                  False,
                                                                  False)
          output          =  [4, 5, 1, 2, 3, _, _, _]
          indices         =  [0, 1, 2, 3, 4, _, _, _]
          inverse_indices =  [0, 1, 2, 3, 4, 4, 0, 1]
          num_unique      =  [5]
  
          [output, indices, inverse_indices, num_unique, counts] = unique([4, 5, 1, 2, 3, 3, 4, 5],
                                                                          False,
                                                                          True)
          output          =  [4, 5, 1, 2, 3, _, _, _]
          indices         =  [0, 1, 2, 3, 4, _, _, _]
          inverse_indices =  [0, 1, 2, 3, 4, 4, 0, 1]
          num_unique      =  [5]
          counts          =  [2, 2, 1, 1, 2, _, _, _]
  
          [output, indices, inverse_indices, num_unique] = unique([4, 5, 1, 2, 3, 3, 4, 5], True)
          output          =  [1, 2, 3, 4, 5, _, _, _]
          indices         =  [2, 3, 4, 0, 1, _, _, _]
          inverse_indices =  [3, 4, 0, 1, 2, 2, 3, 4]
          num_unique      =  [5]
      """
      if return_counts:
          return TupleWrapper(
              _make.unique(data, is_sorted, return_counts), 5
          )
      return TupleWrapper(
          _make.unique(data, is_sorted, return_counts), 4
      )
  
imports: from ...tir import expr
  from ..expr import Constant, Expr, Tuple, TupleWrapper, const
  from .None import _make
  from .dyn import _make
  from .tensor import shape_of
label_desc: Use image node_id 46 for calling a global function with example usage: unique(data, is_sorted, return_counts) and returns: TupleWrapper, TupleWrapper