class_docstr: Find identical samples which have different labels.
  
  Parameters
  ----------
  {text_normalization_params:1*indent}
  n_to_show : int , default: 5
      number of most common ambiguous samples to show.
  n_samples : int , default: 10_000_000
      number of samples to use for this check.
  random_state : int, default: 42
      random seed for all check internals.
  {max_text_length_for_display_param:1*indent}
docstr: Run check.
docstr_tok: ["Run","check","."]
code: def run_logic(self, context: Context, dataset_kind) -> CheckResult:
      """Run check."""
      dataset = context.get_data_by_kind(dataset_kind)
      dataset = dataset.sample(
          self.n_samples,
          random_state=self.random_state,
          drop_na_label=True,
      )
      dataset = t.cast(TextData, dataset)
      n_of_samples = len(dataset)
  
      if n_of_samples == 0:
          raise DeepchecksValueError("Dataset cannot be empty")
  
      # Reduce dataset by first checking on truncated strings
      truncated_samples = [cut_string(x) for x in dataset.text]
  
      df = self._get_df_and_labels(dataset, truncated_samples)
  
      ambiguous_samples_hashes = self._get_conflicting_indices(df)
      indices_to_reinspect = df[
          df["hash"].isin(ambiguous_samples_hashes)
      ].index.to_list()
      dataset = dataset.copy(rows_to_use=indices_to_reinspect)
  
      # Rest of the code can't handle empty dataset
      if len(dataset) == 0:
          result_value = dict(
              percent_of_conflicting_samples=0,
              conflicting_samples=pd.DataFrame(
                  index=pd.MultiIndex(
                      levels=[[], [], []],
                      codes=[[], [], []],
                      names=["Duplicate", "Sample ID", "Label"],
                  ),
                  columns=["Text"],
              ),
          )
          return CheckResult(value=result_value)
  
      # Now that we have narrowed down the dataset, we can check on full strings
      df = self._get_df_and_labels(dataset, dataset.text)
  
      ambiguous_samples_hashes = self._get_conflicting_indices(df)
  
      ambiguous_samples = df[
          df["hash"].isin(ambiguous_samples_hashes)
      ].copy()
      num_of_ambiguous_samples = ambiguous_samples["Text"].count()
      percent_of_ambiguous_samples = (
          num_of_ambiguous_samples / n_of_samples
      )
  
      result_df = ambiguous_samples.rename(
          columns={"hash": "Duplicate"}
      )
      duplicates_enumeration = to_ordional_enumeration(
          result_df["Duplicate"].to_list()
      )
      result_df["Duplicate"] = result_df["Duplicate"].apply(
          lambda x: duplicates_enumeration[x]
      )
      result_df = result_df.set_index(
          ["Duplicate", "Sample ID", "Label"]
      )
  
      result_value = {
          "percent_of_conflicting_samples": percent_of_ambiguous_samples,
          "conflicting_samples": result_df,
      }
  
      if context.with_display is False or num_of_ambiguous_samples == 0:
          return CheckResult(value=result_value)
  
      ambiguous_samples.loc[:, "Text"] = ambiguous_samples[
          "Text"
      ].apply(self._truncate_text)
      by_hash = ambiguous_samples.groupby(["hash"], dropna=False)
      observed_labels = by_hash["Label"].aggregate(
          lambda x: format_list(x.to_list())
      )
      samples_ids = by_hash["Sample ID"].aggregate(
          lambda x: format_list(x.to_list(), max_string_length=200)
      )
      first_in_group = by_hash["Text"].first()
  
      display_table = (
          pd.DataFrame(
              {
                  # TODO:
                  # for multi-label and token classification
                  # 'Observed Labels' column will look not very nice
                  # need an another way to display observed labels
                  # for those task types
                  "Observed Labels": observed_labels,
                  "Sample IDs": samples_ids,
                  "Text": first_in_group,
              }
          )
          .reset_index(drop=True)
          .set_index(["Observed Labels", "Sample IDs"])
      )
      table_description = (
          "Each row in the table shows an example of a data sample "
          "and the its observed conflicting labels as found in the dataset."
      )
      table_note = (
          f"Showing top {self.n_to_show} of {len(display_table)}"
          if self.n_to_show <= len(display_table)
          else ""
      )
      return CheckResult(
          value=result_value,
          display=[
              table_description,
              table_note,
              # slice over first level of the multiindex ('Observed Labels')
              display_table.iloc[slice(0, self.n_to_show)],
          ],
      )
  
imports: import typing
  import numpy
  import pandas
  from deepchecks.core import CheckResult
  from deepchecks.core.errors import DeepchecksValueError
  from deepchecks.nlp import Context, SingleDatasetCheck
  from deepchecks.nlp._shared_docs import docstrings
  from deepchecks.nlp.task_type import TaskType
  from deepchecks.nlp.text_data import TextData
  from deepchecks.nlp.utils.text import cut_string, hash_samples, normalize_samples
  from deepchecks.utils.abstracts.conflicting_labels import ConflictingLabelsAbstract
  from deepchecks.utils.other import to_ordional_enumeration
  from deepchecks.utils.strings import format_list, truncate_string
label_desc: Use image node_id 7 for calling the ConflictingLabels obj's underlying member method code with example usage: obj.run_logic(context, dataset_kind) and returns: CheckResult, CheckResult, CheckResult