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.

def convert(self, vroot, entry_variables):
        """
        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.
        """
        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