code: def get_domain_loaders(self, split="train", batch_size=32):
      rgb_source_ds = (
          rgb_target_ds
      ) = flow_source_ds = flow_target_ds = None
      rgb_source_loader = (
          rgb_target_loader
      ) = flow_source_loader = flow_target_loader = None
      rgb_target_labeled_loader = flow_target_labeled_loader = None
      rgb_target_unlabeled_loader = (
          flow_target_unlabeled_loader
      ) = n_dataset = None
  
      if self.rgb:
          rgb_source_ds = self._rgb_source_by_split[split]
          rgb_source_loader = (
              self._source_sampling_config.create_loader(
                  rgb_source_ds, batch_size
              )
          )
          rgb_target_ds = self._rgb_target_by_split[split]
  
      if self.flow:
          flow_source_ds = self._flow_source_by_split[split]
          flow_source_loader = (
              self._source_sampling_config.create_loader(
                  flow_source_ds, batch_size
              )
          )
          flow_target_ds = self._flow_target_by_split[split]
  
      if self._labeled_target_by_split is None:
          # unsupervised target domain
          if self.rgb:
              rgb_target_loader = (
                  self._target_sampling_config.create_loader(
                      rgb_target_ds, batch_size
                  )
              )
              n_dataset = DatasetSizeType.get_size(
                  self._size_type, rgb_source_ds, rgb_target_ds
              )
          if self.flow:
              flow_target_loader = (
                  self._target_sampling_config.create_loader(
                      flow_target_ds, batch_size
                  )
              )
              n_dataset = DatasetSizeType.get_size(
                  self._size_type, flow_source_ds, flow_target_ds
              )
  
          dataloaders = [
              rgb_source_loader,
              flow_source_loader,
              rgb_target_loader,
              flow_target_loader,
          ]
          dataloaders = [x for x in dataloaders if x is not None]
  
          return MultiDataLoader(
              dataloaders=dataloaders,
              n_batches=max(n_dataset // batch_size, 1),
          )
      else:
          # semi-supervised target domain
          if self.rgb:
              rgb_target_labeled_ds = self._labeled_target_by_split[
                  split
              ]
              rgb_target_unlabeled_ds = rgb_target_ds
              # label domain: always balanced
              rgb_target_labeled_loader = FixedSeedSamplingConfig(
                  balance=True, class_weights=None
              ).create_loader(
                  rgb_target_labeled_ds,
                  batch_size=min(
                      len(rgb_target_labeled_ds), batch_size
                  ),
              )
  
              rgb_target_unlabeled_loader = (
                  self._target_sampling_config.create_loader(
                      rgb_target_unlabeled_ds, batch_size
                  )
              )
              n_dataset = DatasetSizeType.get_size(
                  self._size_type,
                  rgb_source_ds,
                  rgb_target_labeled_ds,
                  rgb_target_unlabeled_ds,
              )
          if self.flow:
              flow_target_labeled_ds = self._labeled_target_by_split[
                  split
              ]
              flow_target_unlabeled_ds = flow_target_ds
              flow_target_labeled_loader = FixedSeedSamplingConfig(
                  balance=True, class_weights=None
              ).create_loader(
                  flow_target_labeled_ds,
                  batch_size=min(
                      len(flow_target_labeled_ds), batch_size
                  ),
              )
              flow_target_unlabeled_loader = (
                  self._target_sampling_config.create_loader(
                      flow_target_unlabeled_ds, batch_size
                  )
              )
              n_dataset = DatasetSizeType.get_size(
                  self._size_type,
                  rgb_source_ds,
                  flow_target_labeled_ds,
                  flow_target_unlabeled_ds,
              )
  
          # combine loaders into a list and remove the loader which is NONE.
          dataloaders = [
              rgb_source_loader,
              flow_source_loader,
              rgb_target_labeled_loader,
              flow_target_labeled_loader,
              rgb_target_unlabeled_loader,
              flow_target_unlabeled_loader,
          ]
          dataloaders = [x for x in dataloaders if x is not None]
  
          return MultiDataLoader(
              dataloaders=dataloaders,
              n_batches=max(n_dataset // batch_size, 1),
          )
  
file_path: pykale/kale/loaddata/video_multi_domain.py
imports: import logging
  import numpy
  from sklearn.utils import check_random_state
  from kale.loaddata.dataset_access import get_class_subset
  from kale.loaddata.multi_domain import DatasetSizeType, MultiDomainDatasets, WeightingType
  from kale.loaddata.sampler import FixedSeedSamplingConfig, MultiDataLoader
  from kale.loaddata.video_access import get_image_modality
label_desc: Use image node_id 3 for calling the VideoMultiDomainDatasets obj's underlying member method code with example usage: obj.get_domain_loaders(split, batch_size) and returns: MultiDataLoader, MultiDataLoader