Hide program APIs (#12315)

* hide program APIs

* fix merge error

* update

Author: typhoonzero

paddle/fluid/API.spec

@@ -1,17 +1,10 @@
 paddle.fluid.Program.__init__ ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
 paddle.fluid.Program.block ArgSpec(args=['self', 'index'], varargs=None, keywords=None, defaults=None)
 paddle.fluid.Program.clone ArgSpec(args=['self', 'for_test'], varargs=None, keywords=None, defaults=(False,))
-paddle.fluid.Program.copy_data_info_from ArgSpec(args=['self', 'other'], varargs=None, keywords=None, defaults=None)
-paddle.fluid.Program.create_block ArgSpec(args=['self', 'parent_idx'], varargs=None, keywords=None, defaults=(None,))
 paddle.fluid.Program.current_block ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
-paddle.fluid.Program.get_desc ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
 paddle.fluid.Program.global_block ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
-paddle.fluid.Program.inference_optimize ArgSpec(args=['self', 'export_for_deployment'], varargs=None, keywords=None, defaults=(True,))
 paddle.fluid.Program.list_vars ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
-paddle.fluid.Program.optimized_guard ArgSpec(args=[], varargs='args', keywords='kwds', defaults=None)
 paddle.fluid.Program.parse_from_string ArgSpec(args=['binary_str'], varargs=None, keywords=None, defaults=None)
-paddle.fluid.Program.prune ArgSpec(args=['self', 'targets'], varargs=None, keywords=None, defaults=None)
-paddle.fluid.Program.rollback ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
 paddle.fluid.Program.to_string ArgSpec(args=['self', 'throw_on_error', 'with_details'], varargs=None, keywords=None, defaults=(False,))
 paddle.fluid.Operator.__init__ ArgSpec(args=['self', 'block', 'desc', 'type', 'inputs', 'outputs', 'attrs'], varargs=None, keywords=None, defaults=(None, None, None, None))
 paddle.fluid.Operator.all_attrs ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)

python/paddle/fluid/backward.py

@@ -347,7 +347,7 @@ def _append_backward_ops_(block,
         # If the op has its own sub-block, deal with the sub-block first
         if op.has_attr("sub_block"):
             sub_block = program.block(op.block_attr_id("sub_block"))
-            grad_sub_block = program.create_block()
+            grad_sub_block = program._create_block()
             grad_sub_block._set_forward_block_idx(sub_block.idx)
             cb = _callback_lookup_(op)
             if cb is not None:
@@ -361,7 +361,7 @@ def _append_backward_ops_(block,
                 _append_backward_ops_(sub_block, sub_block.ops, grad_sub_block,
                                       no_grad_dict, grad_to_var, callbacks)
 
-            program.rollback()
+            program._rollback()
             grad_sub_block_list.append(grad_sub_block.desc)
 
         # Getting op's corresponding grad_op

python/paddle/fluid/clip.py

@@ -331,7 +331,7 @@ def append_gradient_clip_ops(param_grads):
     for p, g in param_grads:
         if g is None:
             continue
-        with p.block.program.optimized_guard([p, g]):
+        with p.block.program._optimized_guard([p, g]):
             clip_attr = getattr(p, 'gradient_clip_attr', NullGradientClipAttr())
             if clip_attr is None:
                 clip_attr = NullGradientClipAttr()
@@ -346,7 +346,7 @@ def append_gradient_clip_ops(param_grads):
     for p, g in param_grads:
         if g is None:
             continue
-        with p.block.program.optimized_guard([p, g]):
+        with p.block.program._optimized_guard([p, g]):
             res.append(clip_attr._create_operators(param=p, grad=g))
 
     return res

python/paddle/fluid/concurrency.py

@@ -126,7 +126,7 @@ def __init__(self,
         self.channel = channel
 
     def __enter__(self):
-        self.block = self.main_program.create_block()
+        self.block = self.main_program._create_block()
 
     def construct_op(self):
         main_program = self.helper.main_program
@@ -187,7 +187,7 @@ def construct_op(self):
                                 if self.value else '')
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.main_program.rollback()
+        self.main_program._rollback()
         if exc_type is not None:
             return False  # re-raise exception
         return True

python/paddle/fluid/framework.py

@@ -935,7 +935,7 @@ class Block(object):
 
     Notes:
         The constructor of Block should not be invoked directly. Please
-        use `Program.create_block()` to create a block.
+        use `Program._create_block()` to create a block.
 
     Examples:
         .. code-block:: python
@@ -1483,7 +1483,7 @@ def set_op_role_var(self, var_name):
         self._op_role_var = [var_name]
 
     @contextlib.contextmanager
-    def optimized_guard(self, param_and_grads):
+    def _optimized_guard(self, param_and_grads):
         """
         A with guard to set :code:`Optimization` :code:`OpRole` and
         :code:`OpRoleVar` automatically.
@@ -1496,7 +1496,7 @@ def optimized_guard(self, param_and_grads):
         Examples:
 
             >>> p, g = backward(...)
-            >>> with program.optimized_guard([p,g]):
+            >>> with program._optimized_guard([p,g]):
             >>>     p = p - 0.001 * g
         """
         OpRole = core.op_proto_and_checker_maker.OpRole
@@ -1554,7 +1554,7 @@ def to_string(self, throw_on_error, with_details=False):
             res_str = _debug_string_(proto, throw_on_error)
         return res_str
 
-    def get_desc(self):
+    def _get_desc(self):
         """
         Get the C++ side of `ProgramDesc` object pointer. The C++ object is
         exposed by :code:`pybind`.
@@ -1647,7 +1647,7 @@ def clone(self, for_test=False):
             The two code snippets above will generate same programs.
         """
         if for_test:
-            p = self.inference_optimize(export_for_deployment=False)
+            p = self._inference_optimize(export_for_deployment=False)
         else:
             p = Program()
             p.current_block_idx = self.current_block_idx
@@ -1663,10 +1663,10 @@ def clone(self, for_test=False):
             p._sync_with_cpp()
 
         p._copy_param_info_from(self)
-        p.copy_data_info_from(self)
+        p._copy_data_info_from(self)
         return p
 
-    def prune(self, targets):
+    def _prune(self, targets):
         """
         Prune operators and variables which are not needed to generate
         :code:`targets`.
@@ -1717,7 +1717,7 @@ def prune(self, targets):
         res._sync_with_cpp()
         return res
 
-    def inference_optimize(self, export_for_deployment=True):
+    def _inference_optimize(self, export_for_deployment=True):
         """
         This method will create a new program and do following adjustments on it:
         1. Remove all reader variables and their creator ops if exist.
@@ -1841,7 +1841,7 @@ def current_block(self):
         """
         return self.blocks[self.current_block_idx]
 
-    def create_block(self, parent_idx=None):
+    def _create_block(self, parent_idx=None):
         """
         Create a new block with the :code:`parent_idx` and change the current block
         to new block.
@@ -1860,7 +1860,7 @@ def create_block(self, parent_idx=None):
         self.blocks.append(Block(self, self.current_block_idx))
         return self.current_block()
 
-    def rollback(self):
+    def _rollback(self):
         """
         Exit a code block, i.e., roll back to the parent block.
         Returns:
@@ -1906,7 +1906,7 @@ def _copy_param_info_from(self, other):
                              "program, with represent the same topology")
         self.global_block()._copy_param_info_from(other.global_block())
 
-    def copy_data_info_from(self, other):
+    def _copy_data_info_from(self, other):
         """
         Copy the information of data variables from other program.
 

python/paddle/fluid/io.py

@@ -515,8 +515,8 @@ def get_inference_program(target_vars, main_program=None):
             vars.extend(var.metrics)
         else:
             vars.append(var)
-    pruned_program = main_program.prune(targets=vars)
-    inference_program = pruned_program.inference_optimize()
+    pruned_program = main_program._prune(targets=vars)
+    inference_program = pruned_program._inference_optimize()
     return inference_program
 
 
@@ -644,8 +644,8 @@ def save_inference_model(dirname,
             global_block._remove_op(i)
     copy_program.desc.flush()
 
-    pruned_program = copy_program.prune(targets=target_vars)
-    inference_program = pruned_program.inference_optimize(
+    pruned_program = copy_program._prune(targets=target_vars)
+    inference_program = pruned_program._inference_optimize(
         export_for_deployment=export_for_deployment)
     fetch_var_names = [v.name for v in target_vars]
 

python/paddle/fluid/layers/control_flow.py

@@ -217,10 +217,10 @@ def __init__(self, main_program):
         self.main_program = main_program
 
     def __enter__(self):
-        self.main_program.create_block()
+        self.main_program._create_block()
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.main_program.rollback()
+        self.main_program._rollback()
         if exc_type is not None:
             return False  # re-raise exception
         return True

python/paddle/fluid/layers/io.py

@@ -1008,9 +1008,9 @@ def _is_completed(self):
     @contextlib.contextmanager
     def block(self):
         self.status = Preprocessor.IN_SUB_BLOCK
-        self.sub_block = self.main_prog.create_block()
+        self.sub_block = self.main_prog._create_block()
         yield
-        self.main_prog.rollback()
+        self.main_prog._rollback()
         self.status = Preprocessor.AFTER_SUB_BLOCK
         if not self._is_completed():
             raise RuntimeError(

python/paddle/fluid/optimizer.py

@@ -236,7 +236,7 @@ def _create_optimization_pass(self,
             for param_and_grad in parameters_and_grads:
                 if param_and_grad[1] is None:
                     continue
-                with param_and_grad[0].block.program.optimized_guard(
+                with param_and_grad[0].block.program._optimized_guard(
                         param_and_grad), name_scope("optimizer"):
                     if param_and_grad[0].trainable is True:
                         optimize_op = self._append_optimize_op(loss.block,
@@ -580,7 +580,7 @@ def _finish_update(self, block, param_and_grads):
         for param, grad in param_and_grads:
             if grad is None:
                 continue
-            with param.block.program.optimized_guard([param, grad]):
+            with param.block.program._optimized_guard([param, grad]):
                 beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
                                                       param)
                 beta2_pow_acc = self._get_accumulator(self._beta2_pow_acc_str,
@@ -709,7 +709,7 @@ def _finish_update(self, block, parameters_and_grads):
         for param, grad in parameters_and_grads:
             if grad is None:
                 continue
-            with param.block.program.optimized_guard([param, grad]):
+            with param.block.program._optimized_guard([param, grad]):
                 beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
                                                       param)
                 main_block.append_op(
@@ -1198,7 +1198,7 @@ def __init__(self,
         for param, grad in self.params_grads:
             if grad is None:
                 continue
-            with param.block.program.optimized_guard([param, grad]):
+            with param.block.program._optimized_guard([param, grad]):
                 self._append_average_accumulate_op(param)
 
         self.apply_program = Program()

python/paddle/fluid/regularizer.py

@@ -47,7 +47,7 @@ def append_regularization_ops(parameters_and_grads, regularization=None):
         if grad is None:
             params_and_grads.append((param, grad))
             continue
-        with param.block.program.optimized_guard([param, grad]):
+        with param.block.program._optimized_guard([param, grad]):
             regularization_term = None
             if param.regularizer is not None:
                 # Add variable for regularization term in grad block