code: def next(self):
      if not self.is_init:
          self.reset()
          self.is_init = True
      """Returns the next batch of data."""
      # print('in next', self.cur, self.labelcur)
      self.nbatch += 1
      batch_size = self.batch_size
      c, h, w = self.data_shape
      batch_data = nd.empty((batch_size, c, h, w))
      if self.provide_label is not None:
          batch_label = nd.empty(self.provide_label[0][1])
      i = 0
      try:
          while i < batch_size:
              label, s, bbox, landmark = self.next_sample()
              _data = self.imdecode(s)
              if _data.shape[0] != self.data_shape[1]:
                  _data = mx.image.resize_short(
                      _data, self.data_shape[1]
                  )
              if self.rand_mirror:
                  _rd = random.randint(0, 1)
                  if _rd == 1:
                      _data = mx.ndarray.flip(data=_data, axis=1)
              if self.color_jittering > 0:
                  if self.color_jittering > 1:
                      _rd = random.randint(0, 1)
                      if _rd == 1:
                          _data = self.compress_aug(_data)
                  # print('do color aug')
                  _data = _data.astype("float32", copy=False)
                  # print(_data.__class__)
                  _data = self.color_aug(_data, 0.125)
              if self.nd_mean is not None:
                  _data = _data.astype("float32", copy=False)
                  _data -= self.nd_mean
                  _data *= 0.0078125
              if self.cutoff > 0:
                  _rd = random.randint(0, 1)
                  if _rd == 1:
                      # print('do cutoff aug', self.cutoff)
                      centerh = random.randint(0, _data.shape[0] - 1)
                      centerw = random.randint(0, _data.shape[1] - 1)
                      half = self.cutoff // 2
                      starth = max(0, centerh - half)
                      endh = min(_data.shape[0], centerh + half)
                      startw = max(0, centerw - half)
                      endw = min(_data.shape[1], centerw + half)
                      # print(starth, endh, startw, endw, _data.shape)
                      _data[starth:endh, startw:endw, :] = 128
              data = [_data]
              try:
                  self.check_valid_image(data)
              except RuntimeError as e:
                  logging.debug("Invalid image, skipping:  %s", str(e))
                  continue
              # print('aa',data[0].shape)
              # data = self.augmentation_transform(data)
              # print('bb',data[0].shape)
              for datum in data:
                  assert (
                      i < batch_size
                  ), "Batch size must be multiples of augmenter output length"
                  # print(datum.shape)
                  batch_data[i][:] = self.postprocess_data(datum)
                  batch_label[i][:] = label
                  i += 1
      except StopIteration:
          if i < batch_size:
              raise StopIteration
  
      return io.DataBatch([batch_data], [batch_label], batch_size - i)
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import os
  import random
  import logging
  import sys
  import numbers
  import math
  import sklearn
  import datetime
  import numpy
  import cv2
  import mxnet
  from mxnet import ndarray
  from mxnet import io
  from mxnet import recordio
label_desc: Use image node_id 11 for calling the FaceImageIter obj's underlying member method code with example usage: obj.next() and returns: io