class_docstr: FFCV loader class that can be used as a drop-in replacement
  for standard (e.g. PyTorch) data loaders.
  
  Parameters
  ----------
  fname: str
      Full path to the location of the dataset (.beton file format).
  batch_size : int
      Batch size.
  num_workers : int
      Number of workers used for data loading. Consider using the actual number of cores instead of the number of threads if you only use JITed augmentations as they usually don't benefit from hyper-threading.
  os_cache : bool
      Leverages the operating for caching purposes. This is beneficial when there is enough memory to cache the dataset and/or when multiple processes on the same machine training using the same dataset. See https://docs.ffcv.io/performance_guide.html for more information.
  order : Union[OrderOption, TraversalOrder]
      Traversal order, one of: SEQUENTIAL, RANDOM, QUASI_RANDOM, or a custom TraversalOrder
  
      QUASI_RANDOM is a random order that tries to be as uniform as possible while minimizing the amount of data read from the disk. Note that it is mostly useful when `os_cache=False`. Currently unavailable in distributed mode.
  distributed : bool
      For distributed training (multiple GPUs). Emulates the behavior of DistributedSampler from PyTorch.
  seed : int
      Random seed for batch ordering.
  indices : Sequence[int]
      Subset of dataset by filtering only some indices.
  pipelines : Mapping[str, Sequence[Union[Operation, torch.nn.Module]]
      Dictionary defining for each field the sequence of Decoders and transforms to apply.
      Fileds with missing entries will use the default pipeline, which consists of the default decoder and `ToTensor()`,
      but a field can also be disabled by explicitly by passing `None` as its pipeline.
  custom_fields : Mapping[str, Field]
      Dictonary informing the loader of the types associated to fields that are using a custom type.
  drop_last : bool
      Drop non-full batch in each iteration.
  batches_ahead : int
      Number of batches prepared in advance; balances latency and memory.
  recompile : bool
      Recompile every iteration. This is necessary if the implementation of some augmentations are expected to change during training.
code: def __len__(self):
      next_order = self.first_traversal_order
      if self.drop_last:
          return len(next_order) // self.batch_size
      else:
          return int(np.ceil(len(next_order) / self.batch_size))
  
imports: import enum
  from os import environ
  import ast
  from multiprocessing import cpu_count
  from re import sub
  from typing import Any, Callable, Mapping, Sequence, Type, Union, Literal
  from collections import defaultdict
  from collections.abc import Collection
  from enum import Enum, unique, auto
  from ffcv.fields.base import Field
  import torch
  import numpy
  from .epoch_iterator import EpochIterator
  from ..reader import Reader
  from ..traversal_order.base import TraversalOrder
  from ..traversal_order import Random, Sequential, QuasiRandom
  from ..pipeline import Pipeline, PipelineSpec, Compiler
  from ..pipeline.operation import Operation
  from ..pipeline.graph import Graph
  from ..memory_managers import ProcessCacheManager, OSCacheManager, MemoryManager
label_desc: Use image node_id 5 for calling the Loader obj's underlying member method code with example usage: obj.__len__() and returns: unknown, int