code: def tile(cls, op: "UniqueLabels"):
      ys = op.ys
      ctx = get_context()
  
      target_types = yield from recursive_tile(
          [type_of_target(x) for x in ys]
      )
      # yield chunks of target_types for execution
      chunks = list(itertools.chain(*(t.chunks for t in target_types)))
      yield chunks
  
      ys_types = set(
          [
              it.item()
              for it in ctx.get_chunks_result([c.key for c in chunks])
          ]
      )
      if ys_types == {"binary", "multiclass"}:
          ys_types = {"multiclass"}
  
      if len(ys_types) > 1:
          raise ValueError(
              "Mix type of y not allowed, got types %s" % ys_types
          )
  
      label_type = ys_types.pop()
  
      # Check consistency for the indicator format
      if label_type == "multilabel-indicator":
          check_arrays = []
          chunks = []
          for y in ys:
              arr = yield from recursive_tile(
                  check_array(y, accept_sparse=True)
              )
              check_arrays.append(arr)
              chunks.extend(arr.chunks)
          yield check_arrays + chunks
          if len(set(arr.shape[1] for arr in check_arrays)) > 1:
              raise ValueError(
                  "Multi-label binary indicator input with "
                  "different numbers of labels"
              )
  
      # Get the unique set of labels
      _unique_labels = _FN_UNIQUE_LABELS.get(label_type, None)
      if not _unique_labels:
          raise ValueError("Unknown label type: %s" % repr(ys))
  
      labels = [_unique_labels(y) for y in ys]
      labels_chunks = []
      ys_labels = set()
      for label in labels:
          if isinstance(label, ENTITY_TYPE):
              label = yield from recursive_tile(label)
              labels_chunks.extend(label.chunks)
          else:
              ys_labels.update(label)
      yield labels_chunks
      ys_labels.update(
          itertools.chain.from_iterable(
              ctx.get_chunks_result([c.key for c in labels_chunks])
          )
      )
  
      # Check that we don't mix string type with number type
      if len(set(isinstance(label, str) for label in ys_labels)) > 1:
          raise ValueError(
              "Mix of label input types (string and number)"
          )
  
      return (yield from recursive_tile(mt.array(sorted(ys_labels))))
  
imports: import itertools
  from collections.abc import Sequence
  from typing import List
  import numpy
  from scipy.sparse import spmatrix
  from sklearn.utils.multiclass import is_multilabel, type_of_target
  from ...None import opcodes
  from ...None import tensor
  from ...core import ENTITY_TYPE, TILEABLE_TYPE, recursive_tile
  from ...core.context import get_context
  from ...serialization.serializables import AnyField, ListField
  from ...tensor.core import TensorOrder, TENSOR_TYPE
  from ...typing import TileableType
  from ...utils import has_unknown_shape
  from ..operands import LearnOperand, LearnOperandMixin, OutputType
  from ..utils import assert_all_finite
  from .validation import check_array
label_desc: Use image node_id 2 for calling the UniqueLabels obj's underlying member method code with example usage: obj.tile(cls, op) and returns: unknown