code: def bind(self, data_shapes, label_shapes=None, for_training=True,
               inputs_need_grad=False, force_rebind=False, shared_module=None, grad_req='write'):
          
          # force rebinding is typically used when one want to switch from
          # training to prediction phase.
          super(SVRGModule, self).bind(data_shapes, label_shapes, for_training, inputs_need_grad, force_rebind,
                                       shared_module, grad_req)
  
          if for_training:
              self._mod_aux.bind(data_shapes, label_shapes, for_training, inputs_need_grad, force_rebind, shared_module,
                                 grad_req)
docs: Binds the symbols to construct executors for both two modules. This is necessary before one
          can perform computation with the SVRGModule.
  
          Parameters
          ----------
          data_shapes : list of (str, tuple)
              Typically is ``data_iter.provide_data``.
          label_shapes : list of (str, tuple)
              Typically is ``data_iter.provide_label``.
          for_training : bool
              Default is ``True``. Whether the executors should be bound for training.
          inputs_need_grad : bool
              Default is ``False``. Whether the gradients to the input data need to be computed.
              Typically this is not needed. But this might be needed when implementing composition
              of modules.
          force_rebind : bool
              Default is ``False``. This function does nothing if the executors are already
              bound. But with this ``True``, the executors will be forced to rebind.
          shared_module : Module
              Default is ``None``. This is used in bucketing. When not ``None``, the shared module
              essentially corresponds to a different bucket -- a module with different symbol
              but with the same sets of parameters (e.g. unrolled RNNs with different lengths).