code: def _load_dataset_multi_path_helper(
      self,
      split: str,
      src_multiple_bin_paths: Dict[str, str],
      tgt_multiple_bin_paths: Dict[str, str],
      dataset_upsampling: Optional[Dict[str, float]] = None,
      dataset_relative_ratio: Optional[Tuple[str, float]] = None,
      seed: Optional[int] = None,
      noiser: Optional[Dict[str, UnsupervisedMTNoising]] = None,
      is_npz: bool = True,
  ):
      corpora_map = pytorch_translate_data.ParallelCorporaMapConfig(
          src_files=src_multiple_bin_paths,
          tgt_files=tgt_multiple_bin_paths,
      )
      datasets = OrderedDict()
      for key in corpora_map.src_files:
          src, tgt = (
              corpora_map.src_files[key],
              corpora_map.tgt_files[key],
          )
          if self.char_target_dict is not None:
              tgt_dataset = char_data.InMemoryNumpyWordCharDataset.create_from_file(
                  tgt
              )
          else:
              tgt_dataset = pytorch_translate_data.InMemoryIndexedDataset.create_from_file(
                  tgt, is_npz=is_npz
              )
  
          if self.char_source_dict is not None:
              src_dataset = char_data.InMemoryNumpyWordCharDataset.create_from_file(
                  src
              )
          else:
              src_dataset = pytorch_translate_data.InMemoryIndexedDataset.create_from_file(
                  src, is_npz=is_npz
              )
          src_sizes = src_dataset.sizes
          if noiser is not None and key in noiser:
              src_dataset = NoisingDataset(
                  src_dataset=src_dataset,
                  src_dict=self.source_dictionary,
                  seed=seed,
                  noiser=noiser[key],
              )
          if self.char_source_dict is not None:
              char_data_class = (
                  char_data.LanguagePairCharDataset
                  if self.char_target_dict is not None
                  else char_data.LanguagePairSourceCharDataset
              )
              datasets[key] = char_data_class(
                  src=src_dataset,
                  src_sizes=src_sizes,
                  src_dict=self.source_dictionary,
                  tgt=tgt_dataset,
                  tgt_sizes=tgt_dataset.sizes,
                  tgt_dict=self.target_dictionary,
              )
          else:
              datasets[key] = LanguagePairDataset(
                  src=src_dataset,
                  src_sizes=src_sizes,
                  src_dict=self.source_dictionary,
                  tgt=tgt_dataset,
                  tgt_sizes=tgt_dataset.sizes,
                  tgt_dict=self.target_dictionary,
                  left_pad_source=False,
              )
      total_line_count = sum(len(datasets[key]) for key in datasets)
      if dataset_relative_ratio:
          ds, ratio = dataset_relative_ratio
          line_count = len(datasets[ds])
          # By definition ratio = u * line_count / sum(#lines of other datasets)
          u = (total_line_count - line_count) / line_count * ratio
          dataset_upsampling = {key: u}
      elif not dataset_upsampling:
          dataset_upsampling = {}
  
      print(f"|dataset upsampling:{dataset_upsampling}")
      ds_list = []
      sample_ratios = []
      for key, val in datasets.items():
          ds_list.append(val)
          sample_ratios.append(int(dataset_upsampling.get(key, 1)))
  
      self.datasets[split] = LanguagePairUpsamplingDataset(
          datasets=datasets.values(), sample_ratios=sample_ratios
      )
  
imports: import os
  from collections import OrderedDict
  from typing import Dict, List, Optional, Tuple
  import numpy
  from fairseq import data, options
  from fairseq.data import ConcatDataset, LanguagePairDataset, NoisingDataset
  from fairseq.data.multi_corpus_sampled_dataset import MultiCorpusSampledDataset
  from fairseq.data.noising import UnsupervisedMTNoising
  from fairseq.tasks import LegacyFairseqTask, register_task
  from pytorch_translate import constants, utils
  from pytorch_translate.data import char_data, data, dictionary, utils, weighted_data
  from pytorch_translate.data.language_pair_upsampling_dataset import LanguagePairUpsamplingDataset
  from pytorch_translate.research.multisource import multisource_data
label_desc: Use image node_id 7 for calling the PytorchTranslateTask obj's underlying member method code with example usage: obj._load_dataset_multi_path_helper(split, src_multiple_bin_paths, tgt_multiple_bin_paths, dataset_upsampling, dataset_relative_ratio, seed, noiser, is_npz) without return types