code: def __init__(
      self,
      binary_file_path: str,
      batch_size: int,
      drop_last_batch,
      **kwargs,
  ):
      self._batch_size = batch_size
      bytes_per_feature = {}
      for name in DEFAULT_INT_NAMES:
          bytes_per_feature[name] = np.dtype(np.float32).itemsize
      for name in DEFAULT_CAT_NAMES:
          bytes_per_feature[name] = np.dtype(np.int32).itemsize
  
      self._numerical_features_file = None
      self._label_file = None
      self._categorical_features_files = []
  
      self._numerical_bytes_per_batch = (
          bytes_per_feature[DEFAULT_INT_NAMES[0]]
          * len(DEFAULT_INT_NAMES)
          * batch_size
      )
      self._label_bytes_per_batch = (
          np.dtype(np.float32).itemsize * batch_size
      )
      self._categorical_bytes_per_batch = [
          bytes_per_feature[feature] * self._batch_size
          for feature in DEFAULT_CAT_NAMES
      ]
      # Load categorical
      for feature_name in DEFAULT_CAT_NAMES:
          path_to_open = os.path.join(
              binary_file_path, f"{feature_name}.bin"
          )
          cat_file = os.open(path_to_open, os.O_RDONLY)
          bytes_per_batch = (
              bytes_per_feature[feature_name] * self._batch_size
          )
          batch_num_float = os.fstat(cat_file).st_size / bytes_per_batch
          self._categorical_features_files.append(cat_file)
  
      # Load numerical
      path_to_open = os.path.join(binary_file_path, "numerical.bin")
      self._numerical_features_file = os.open(path_to_open, os.O_RDONLY)
      batch_num_float = (
          os.fstat(self._numerical_features_file).st_size
          / self._numerical_bytes_per_batch
      )
  
      # Load label
      path_to_open = os.path.join(binary_file_path, "label.bin")
      self._label_file = os.open(path_to_open, os.O_RDONLY)
      batch_num_float = (
          os.fstat(self._label_file).st_size
          / self._label_bytes_per_batch
      )
      # number of batches means the ALL data for all ranks
      number_of_batches = (
          math.ceil(batch_num_float)
          if not drop_last_batch
          else math.floor(batch_num_float)
      )
      # for this data_loader, we should divide the num_batch by world_size
      self._num_entries = number_of_batches
  
      self._executor = concurrent.futures.ThreadPoolExecutor(
          max_workers=1
      )
  
imports: import concurrent
  import math
  import os
  from typing import Dict, List, Optional, Tuple
  import numpy
  import torch
  from torch.utils import data
  from torch.utils.data import Dataset
  from torch.utils.data.distributed import DistributedSampler
  from torchrec.datasets.criteo import CAT_FEATURE_COUNT, DEFAULT_CAT_NAMES, DEFAULT_INT_NAMES
  from torchrec.datasets.utils import Batch
  from torchrec.sparse.jagged_tensor import KeyedJaggedTensor
label_desc: Use image node_id 1 to create a new ParametricDataset object from inherited base classes: Dataset with example: obj = ParametricDataset(binary_file_path, batch_size, drop_last_batch)