code: def load_dataset_only(
      self, split, lang_pairs, do_mask=True, epoch=1, combine=False
  ):
      paths = utils.split_paths(self.args.data)
      assert len(paths) > 0
      data_path = paths[(epoch - 1) % len(paths)]
  
      # TODO unk token will be considered as first word too, though it might be an unknown phoneme within a word
      # get_whole_word_mask returns a tensor (size V by 1 ) to indicate if a token is a word start token
      mask_whole_src_words = gen_whole_word_mask(
          self.args, self.src_dict
      )
      language_without_segmentations = (
          self.args.no_whole_word_mask_langs.split(",")
      )
      lang_datasets = []
      eos_bos = []
      lang_pairs = lang_pairs.split(",") if lang_pairs != "" else []
      assert len(lang_pairs) > 0
      for lp in lang_pairs:
          src, tgt = lp.split("-")
          lang_mask_whole_src_words = (
              mask_whole_src_words
              if src not in language_without_segmentations
              else None
          )
  
          end_token = (
              self.source_dictionary.index(
                  PairedDenoisingTask.LANG_TAG_TEMPLATE.format(src)
              )
              if self.args.add_src_lang_token
              else None
          )
          bos_token = (
              self.target_dictionary.index(
                  PairedDenoisingTask.LANG_TAG_TEMPLATE.format(tgt)
              )
              if self.args.add_tgt_lang_token
              else None
          )
          src_lang_id = None
  
          if (
              self.args.add_src_lang_token
              or self.args.add_tgt_lang_token
          ):
              eos_bos.append((end_token, bos_token))
  
          dataset = PairedDenoisingTask.language_pair_denoising_dataset(
              data_path,
              do_mask,
              split,
              src,
              self.source_dictionary,
              tgt,
              self.target_dictionary,
              self.mask_idx,
              lang_mask_whole_src_words,
              self.args.seed,
              self.args,
              self.args.dataset_impl,
              combine=combine,
              left_pad_source=utils.eval_bool(
                  self.args.left_pad_source
              ),
              left_pad_target=utils.eval_bool(
                  self.args.left_pad_target
              ),
              max_source_positions=self.args.max_source_positions,
              max_target_positions=self.args.max_target_positions,
              src_lang_id=src_lang_id,
          )
  
          lang_datasets.append(dataset)
  
      if len(lang_datasets) == 0:
          return
      elif len(lang_datasets) == 1:
          dataset = lang_datasets[0]
          if (
              self.args.add_src_lang_token
              or self.args.add_tgt_lang_token
          ):
              end_token, bos_token = eos_bos[0]
              dataset = TransformEosLangPairDataset(
                  dataset,
                  src_eos=self.source_dictionary.eos(),
                  new_src_eos=end_token,
                  tgt_bos=self.target_dictionary.eos(),
                  new_tgt_bos=bos_token,
              )
      else:
          end_tokens = [
              item[0] for item in eos_bos if item[0] is not None
          ]
          bos_tokens = [
              item[1] for item in eos_bos if item[1] is not None
          ]
          lang_datasets = self.resample_datasets(
              lang_datasets, lang_pairs, epoch
          )
          dataset = TransformEosConcatLangPairDataset(
              lang_datasets,
              self.source_dictionary.eos(),
              self.target_dictionary.eos(),
              new_src_eos=end_tokens,
              new_tgt_bos=bos_tokens,
          )
      return dataset
  
imports: import itertools
  import logging
  import os
  import re
  import numpy
  import torch
  from examples.speech_text_joint_to_text.data.pair_denoising_dataset import LanguagePairDenoisingDataset
  from fairseq import utils
  from fairseq.data import ConcatDataset, Dictionary, LanguagePairDataset, ResamplingDataset, TransformEosConcatLangPairDataset, TransformEosLangPairDataset, data_utils, indexed_dataset
  from fairseq.data.encoders.utils import get_whole_word_mask
  from fairseq.tasks import register_task
  from fairseq.tasks.translation import TranslationTask
label_desc: Use image node_id 7 for calling the PairedDenoisingTask obj's underlying member method code with example usage: obj.load_dataset_only(split, lang_pairs, do_mask, epoch, combine) and returns: dataset