class_docstr: DALI Pipeline with SSD training transform.
  
  Parameters
  ----------
  device_id: int
       DALI pipeline arg - Device id.
  num_workers:
      DALI pipeline arg - Number of CPU workers.
  batch_size:
      Batch size.
  data_shape: int
      Height and width length. (height==width in SSD)
  anchors: float list
      Normalized [ltrb] anchors generated from SSD networks.
      The shape length be ``N*4`` since it is a list of the N anchors that have
      all 4 float elements.
  dataset_reader: float
      Partial pipeline object, which __call__ function has to return
      (images, bboxes, labels) DALI EdgeReference tuple.
  seed: int
      Random seed. Default value is -1, which corresponds to no seed.
code: def __init__(
      self,
      num_workers,
      device_id,
      batch_size,
      data_shape,
      anchors,
      dataset_reader,
      seed=-1,
  ):
      super(SSDDALIPipeline, self).__init__(
          batch_size=batch_size,
          device_id=device_id,
          num_threads=num_workers,
          seed=seed,
      )
  
      self.dataset_reader = dataset_reader
  
      # Augumentation techniques
      self.crop = dali.ops.RandomBBoxCrop(
          device="cpu",
          aspect_ratio=[0.5, 2.0],
          thresholds=[0, 0.1, 0.3, 0.5, 0.7, 0.9],
          scaling=[0.3, 1.0],
          ltrb=True,
          allow_no_crop=True,
          num_attempts=1,
      )
      self.slice = dali.ops.Slice(device="cpu")
      self.twist = dali.ops.ColorTwist(device="gpu")
      self.resize = dali.ops.Resize(
          device="cpu",
          resize_x=data_shape,
          resize_y=data_shape,
          min_filter=dali.types.DALIInterpType.INTERP_TRIANGULAR,
      )
  
      # output_dtype = types.FLOAT16 if args.fp16 else types.FLOAT
      output_dtype = dali.types.FLOAT
  
      self.normalize = dali.ops.CropMirrorNormalize(
          device="gpu",
          crop=(data_shape, data_shape),
          mean=[0.485 * 255, 0.456 * 255, 0.406 * 255],
          std=[0.229 * 255, 0.224 * 255, 0.225 * 255],
          mirror=0,
          output_dtype=output_dtype,
          output_layout=dali.types.NCHW,
          pad_output=False,
      )
  
      # Random variables
      self.rng1 = dali.ops.Uniform(range=[0.5, 1.5])
      self.rng2 = dali.ops.Uniform(range=[0.875, 1.125])
      self.rng3 = dali.ops.Uniform(range=[-0.5, 0.5])
  
      self.flip = dali.ops.Flip(device="cpu")
      self.bbflip = dali.ops.BbFlip(device="cpu", ltrb=True)
      self.flip_coin = dali.ops.CoinFlip(probability=0.5)
  
      self.box_encoder = dali.ops.BoxEncoder(
          device="cpu",
          criteria=0.5,
          anchors=self._to_normalized_ltrb_list(anchors, data_shape),
          offset=True,
          stds=[0.1, 0.1, 0.2, 0.2],
          scale=data_shape,
      )
  
imports: from __future__ import absolute_import
  import numpy
  import mxnet
  from ..None import bbox
  from ..None import image
  from ..None import experimental
  from ....utils import try_import_dali
label_desc: Use image node_id 1 to create a new SSDDALIPipeline object from inherited base classes: dali with example: obj = SSDDALIPipeline(num_workers, device_id, batch_size, data_shape, anchors, dataset_reader, seed)