code: def compute_internal(self, sym_name, bucket_kwargs=None, **arg_dict):
          
          data_shapes = {k: v.shape for k, v in arg_dict.items()}
          self.switch_bucket(bucket_kwargs=bucket_kwargs,
                             data_shapes=data_shapes)
          internal_sym = self.sym.get_internals()[sym_name]
          data_inputs = {k: mx.nd.empty(v, ctx=self.ctx)
                         for k, v in self.data_shapes.items()
                         if k in internal_sym.list_arguments()}
          params = {k: v for k, v in self.params.items() if
                    k in internal_sym.list_arguments()}
          aux_states = {k: v for k, v in self.aux_states.items()
                        if k in internal_sym.list_auxiliary_states()}
          exe = internal_sym.bind(ctx=self.ctx,
                                  args=dict(params, **data_inputs),
                                  args_grad=None,
                                  grad_req='null',
                                  aux_states=aux_states,
                                  shared_exec=self.exe)
          for k, v in arg_dict.items():
              exe.arg_dict[k][:] = v
          exe.forward(is_train=False)
          assert 1 == len(exe.outputs)
          for output in exe.outputs:
              output.wait_to_read()
          return exe.outputs[0]
docs: View the internal symbols using the forward function.
  
          :param sym_name:
          :param bucket_kwargs:
          :param input_dict:
          :return: