code: def convert(self, vroot, entry_variables):
          
          self.graph_info = GraphInfo(vroot)
          self.entry_variables = entry_variables
  
          with nn.parameter_scope(self.name):
              # Function loop in the forward order
              for t, func in enumerate(self.graph_info.funcs):
                  # TODO: error check
  
                  # Batch normalization check, then skip
                  if func.name == "BatchNormalization":
                      i0 = func.inputs[0]
                      bn_func = func
                      # Test mode check
                      if bn_func.info.args["batch_stat"] == False:
                          # `Target Func -> BN` check from BN
                          if i0.parent.info.type_name in self.inner_prod_functions:
                              nn.logger.info("{} is skipped.".format(func.name))
                              continue
  
                  # `Target Func -> BN` conversion
                  if func.name in self.inner_prod_functions:
                      inner_prod_func = func
  
                      o0 = inner_prod_func.outputs[0]
                      fs = self.graph_info.variable_to_funcs[o0]
                      # No branch check #TODO: branching check (really needed?)
                      if fs is not None and len(fs) == 1:
                          # `Target Func -> BN` check
                          bn_func = fs[0]
                          if bn_func.name == "BatchNormalization":
  
                              # Test mode check
                              if bn_func.info.args["batch_stat"] == False:
  
                                  # Perform `Target Func -> BN` conversion
                                  nn.logger.info("BatchNormalization parameters are folded to "
                                                 "the preceding convolution.")
                                  o = self._inner_prod_bn_conversion(
                                      inner_prod_func, bn_func)
                                  continue
  
                  # Identity conversion
                  o = self._identity_conversion(func)
  
          self.end_variable = o
          return self.end_variable
docs: All functions are replaced with the same `new` function.
  
          Args:
              vroot (:obj:`Variable`): NNabla Variable
              entry_variables (:obj:`Variable`): Entry variable from which the conversion starts.