class_docstr: Large-scale distributed sampling face recognition training Module, of course sampling is an option,
  There will be no loss of accuracy in sampling in large-scale identities training tasks, uses only
  8 NVIDIA RTX2080Ti to complete classification tasks with 10 millions of identities, 64 NVIDIA
  RTX2080Ti can complete classification tasks with 100 million of identities.
  
  See the original paper:
  https://arxiv.org/abs/2203.15565
  
  Parameters
  ----------
  symbol: Symbol
      Backbone symbol.
  fc7_model: Object
      Object of margin loss.
  memory_bank: Memory bank Object.
      Object of memory bank, which maintain local class centers and their momentum.
  memory_optimizer: Optimizer object.
      The updater of memory bank, default is sgd optimizer.
  logger:
code: def fit(
      self,
      train_data,
      optimizer_params,
      batch_end_callback,
      initializer,
      arg_params=None,
      aux_params=None,
  ):
      # Bind -> Init_params -> Init_optimizers
      self.bind(train_data.provide_data, train_data.provide_label, True)
      self.init_params(initializer, arg_params, aux_params, False)
      self.init_optimizer(optimizer_params=optimizer_params)
  
      # Sync init
      _arg_params, _aux_params = self.backbone_module.get_params()
      _arg_params_rank_0 = self.broadcast_parameters(_arg_params)
      _aux_params_rank_0 = self.broadcast_parameters(_aux_params)
      self.backbone_module.set_params(
          _arg_params_rank_0, _aux_params_rank_0
      )
  
      # Training loop
      num_epoch = 0
      while True:
          data_iter = iter(train_data)
          end_of_batch = False
          next_data_batch = next(data_iter)
  
          while not end_of_batch:
              data_batch = next_data_batch
              self.forward_backward(data_batch)
              self.update()
              try:
                  # pre fetch next batch
                  next_data_batch = next(data_iter)
                  self.prepare(next_data_batch, sparse_row_id_fn=None)
              except StopIteration:
                  num_epoch += 1
                  end_of_batch = True
                  logging.info("reset dataset")
                  train_data.reset()
  
              if batch_end_callback is not None:
                  batch_end_params = self.batch_end_param(
                      loss=self.loss_cache,
                      num_epoch=num_epoch,
                      num_update=self.num_update,
                  )
                  batch_end_callback(batch_end_params)
  
imports: import logging
  import warnings
  from collections import namedtuple
  import horovod.mxnet
  import mxnet
  import mxnet.ndarray
  import numpy
  from default import config
  from optimizer import DistributedOptimizer
label_desc: Use image node_id 4 for calling the SampleDistributeModule obj's underlying member method code with example usage: obj.fit(train_data, optimizer_params, batch_end_callback, initializer, arg_params, aux_params) without return types