support dygraph basic api transformed to static api (#22678)

* support dygraph to static graph for simple case.

* add test for dygraph API recognition. test=develop

* support basic to_variable api. test=develop

* update dict: dygraph_class_to_static_api

* add all tests of dygraph api. test=develop

* use gast/astor instead of ast/codegen for the compatibility of PY2 and PY3. test=develop

* add arg 'num_flatten_dims' for fc ast node. test=develop

* Modify names of class by Camel-Case.

python/paddle/fluid/dygraph/dygraph_to_static/ast_transformer.py

@@ -13,7 +13,8 @@
 # limitations under the License.
 
 from __future__ import print_function
-
+import astor
+from .utils import *
 import gast
 # gast is a generic AST to represent Python2 and Python3's Abstract Syntax Tree(AST).
 # It provides a compatibility layer between the AST of various Python versions,
@@ -66,7 +67,7 @@ class IfElseTransformer(gast.NodeTransformer):
 
     def visit_Call(self, node):
         # Remove `numpy()` statement, like `Tensor.numpy()[i]` -> `Tensor[i]`
-        # Todo: should be removed. it may be considered as basic api transformation.
+        # TODO: should be removed. it may be considered as basic api transformation.
         if isinstance(node.func, gast.Attribute):
             attribute = node.func
             if attribute.attr == 'numpy':
@@ -105,6 +106,10 @@ class DygraphToStaticAst(gast.NodeTransformer):
     def transfer_from_node_type(self, node):
         # Generic transformation
         self.visit(node.node)
+
+        # Transform basic api of dygraph to static graph
+        BasicApiTransformer(node).ast_visit()
+
         # Transform all if/else statement of Dygraph into Static Graph.
         IfElseTransformer(node).ast_visit()
 
@@ -128,3 +133,89 @@ class DygraphToStaticAst(gast.NodeTransformer):
         # Should consider BaseAPITransformer which add new module name in Yamei's PR.
         assert self.decorate_func_name, "decorate_func_name shall not be None."
         return self.decorate_func_name
+
+
+class BasicApiTransformer(gast.NodeTransformer):
+    """
+    Class to transform basic API from dygraph to static graph.
+    """
+
+    def __init__(self, wrapper_root):
+        assert isinstance(
+            wrapper_root, AstNodeWrapper
+        ), "Input non-AstNodeWrapper node for the initialization of BasicApiTransformer."
+        self.wrapper_root = wrapper_root
+        self.root = wrapper_root.node
+        self.class_node_dict = {}
+
+    def ast_visit(self):
+        self.visit(self.root)
+        return self.wrapper_root
+
+    def visit_FunctionDef(self, node):
+        self.generic_visit(node)
+        if hasattr(node, 'decorator_list'):
+            decorator_list = [
+                d for d in node.decorator_list if d.id != DECORATOR_NAME
+            ]
+            node.decorator_list = decorator_list
+        return node
+
+    def visit_Assign(self, node):
+        if self._update_class_node_dict(node):
+            return None
+
+        value_node = node.value
+        for child_node in gast.walk(value_node):
+            if isinstance(child_node, gast.Call):
+                self._visit_Call(child_node)
+
+        return node
+
+    def visit_Expr(self, node):
+        value_node = node.value
+        for child_node in gast.walk(value_node):
+            if isinstance(child_node, gast.Call):
+                if is_dygraph_api(child_node):
+                    return
+                else:
+                    self._visit_Call(child_node)
+
+        return node
+
+    def _visit_Call(self, node):
+        assert isinstance(node, gast.Call)
+
+        # Replace API `to_variable` with `fluid.layers.assign`
+        if is_to_variable(node):
+            node = to_assign_node(node)
+            return node
+
+        func_name = astor.to_source(node.func)
+        if self._is_dygraph_forward(func_name):
+            class_node = self._get_class_node(func_name)
+            static_node = to_static_ast(node, class_node)
+            return static_node
+        else:
+            return node
+
+    def _is_dygraph_forward(self, func_id):
+        return func_id in self.class_node_dict
+
+    def _get_class_node(self, func_id):
+        return self.class_node_dict[func_id]
+
+    def _update_class_node_dict(self, node):
+        assert isinstance(node, gast.Assign)
+        node_value = node.value
+        if isinstance(node_value, gast.Call):
+            if is_to_variable(node_value):
+                return False
+
+            if is_dygraph_api(node_value):
+                update_args_of_func(node_value, node_value, "__init__")
+                target_str = astor.to_source(node.targets[0])
+                self.class_node_dict[target_str] = node_value
+                return True
+            # TODO: node.value is not dygraph class
+        return False

python/paddle/fluid/dygraph/dygraph_to_static/utils.py

@@ -0,0 +1,177 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import inspect
+import gast
+import astor
+import atexit
+import os
+import tempfile
+import six
+import imp
+
+dygraph_class_to_static_api = {
+    "BatchNorm": "batch_norm",
+    "BilinearTensorProduct": "bilinear_tensor_product",
+    "Conv2D": "conv2d",
+    "Conv3D": "conv3d",
+    "Conv2DTranspose": "conv2d_transpose",
+    "Conv3DTranspose": "conv3d_transpose",
+    "CosineDecay": "cosine_decay",
+    "Embedding": "embedding",
+    "ExponentialDecay": "exponential_decay",
+    "GroupNorm": "group_norm",
+    "GRUUnit": "gru_unit",
+    "InverseTimeDecay": "inverse_time_decay",
+    "LayerNorm": "layer_norm",
+    "Linear": "fc",
+    "NaturalExpDecay": "natural_exp_decay",
+    "NCE": "nce",
+    "NoamDecay": "noam_decay",
+    "PiecewiseDecay": "piecewise_decay",
+    "PolynomialDecay": "polynomial_decay",
+    "Pool2D": "pool2d",
+    "PRelu": "prelu",
+    "SpectralNorm": "spectral_norm",
+}
+
+
+def _delete_keywords_from(node):
+    assert isinstance(node, gast.Call)
+    func_src = astor.to_source(node.func)
+    import paddle.fluid as fluid
+    full_args = eval("inspect.getargspec({})".format(func_src))
+    full_args_name = full_args[0]
+
+    node.keywords = [k for k in node.keywords if k.arg in full_args_name]
+    return
+
+
+def to_static_api(dygraph_class):
+    if dygraph_class in dygraph_class_to_static_api:
+        return dygraph_class_to_static_api[dygraph_class]
+    else:
+        raise NotImplementedError("Paddle dygraph API {} cannot be converted "
+                                  "to static graph at present.".format(
+                                      dygraph_class))
+
+
+def _add_keywords_to(node, dygraph_api_name):
+    assert isinstance(node, gast.Call)
+    if dygraph_api_name == "Linear":
+        for ast_keyword in node.keywords:
+            if ast_keyword.arg == "output_dim":
+                ast_keyword.arg = "size"
+
+        node.keywords.append(
+            gast.keyword(
+                arg="num_flatten_dims",
+                value=gast.Constant(
+                    value=-1, kind=None)))
+
+    if dygraph_api_name == "BilinearTensorProduct":
+        for ast_keyword in node.keywords:
+            if ast_keyword.arg == "output_dim":
+                ast_keyword.arg = "size"
+
+    if dygraph_api_name == "PRelu":
+        for ast_keyword in node.keywords:
+            if ast_keyword.arg == "input":
+                ast_keyword.arg = "x"
+    return
+
+
+def _is_paddle_dygraph_api(obj):
+    m = inspect.getmodule(obj)
+    return m is not None and m.__name__.startswith("paddle.fluid.dygraph")
+
+
+def is_dygraph_api(node):
+    assert isinstance(node, gast.Call)
+    func_src = astor.to_source(node.func)
+    try:
+        import paddle.fluid as fluid
+        return eval("_is_paddle_dygraph_api({})".format(func_src))
+    except NameError:
+        return False
+
+
+def is_to_variable(node):
+    assert isinstance(node, gast.Call)
+    if is_dygraph_api(node):
+        api_name = node.func.attr
+        return api_name == "to_variable"
+    return False
+
+
+def to_static_ast(node, class_node):
+    assert isinstance(node, gast.Call)
+    assert isinstance(class_node, gast.Call)
+    static_api = to_static_api(class_node.func.attr)
+
+    node.func = gast.Attribute(
+        attr=static_api,
+        ctx=gast.Load(),
+        value=gast.Attribute(
+            attr='layers',
+            ctx=gast.Load(),
+            value=gast.Name(
+                ctx=gast.Load(), id='fluid', annotation=None,
+                type_comment=None)))
+
+    update_args_of_func(node, class_node, 'forward')
+
+    node.args.extend(class_node.args)
+    node.keywords.extend(class_node.keywords)
+    _add_keywords_to(node, class_node.func.attr)
+    _delete_keywords_from(node)
+
+    gast.fix_missing_locations(node)
+
+    return node
+
+
+def to_assign_node(ori_node):
+    assert isinstance(ori_node, gast.Call)
+    assign_api = gast.parse('fluid.layers.assign').body[0].value
+    ori_node.func = assign_api
+    return ori_node
+
+
+def update_args_of_func(node, dygraph_node, method_name):
+    assert isinstance(node, gast.Call)
+    if method_name not in ["__init__", "forward"]:
+        raise ValueError(
+            "The method name of class to update args should be '__init__' or 'forward'"
+        )
+
+    class_src = astor.to_source(dygraph_node.func)
+    import paddle.fluid as fluid
+    if method_name == "__init__" or eval(
+            "issubclass({}, fluid.dygraph.Layer)".format(class_src)):
+        full_args = eval("inspect.getargspec({}.{})".format(class_src,
+                                                            method_name))
+        full_args_name = [
+            arg_name for arg_name in full_args[0] if arg_name != "self"
+        ]
+    else:
+        full_args_name = []
+    added_keywords = []
+    for idx, arg in enumerate(node.args):
+        added_keywords.append(gast.keyword(arg=full_args_name[idx], value=arg))
+
+    node.args = []
+    node.keywords = added_keywords + node.keywords

python/paddle/fluid/dygraph/jit.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import print_function
+
 __all__ = ['TracedLayer', 'dygraph_to_static_output']
 
 import gast
@@ -58,11 +60,11 @@ def _dygraph_to_static_output_(dygraph_func):
         dygraph_code = inspect.getsource(dygraph_func)
         dygraph_code = textwrap.dedent(dygraph_code)
         root = gast.parse(dygraph_code)
+
         # Transform AST
         dygraph_to_static = DygraphToStaticAst()
         root_wrapper = dygraph_to_static.get_static_ast(root)
         func_name = dygraph_to_static.get_module_name()
-
         static_func, file_name = ast_to_func(root_wrapper.node, func_name)
 
         return static_func(*args, **kwargs)
@@ -108,17 +110,17 @@ def _trace(layer,
 
 class TracedLayer(object):
     """
-    TracedLayer is used to convert a forward dygraph model to a static 
-    graph model. This is mainly used to save the dygraph model for online 
-    inference using C++. Besides, users can also do inference in Python 
-    using the converted static graph model, which usually has better 
-    performance than the original dygraph model.  
+    TracedLayer is used to convert a forward dygraph model to a static
+    graph model. This is mainly used to save the dygraph model for online
+    inference using C++. Besides, users can also do inference in Python
+    using the converted static graph model, which usually has better
+    performance than the original dygraph model.
 
     TracedLayer would run the static graph model using :code:`Executor`
     and :code:`CompiledProgram` . The static graph model would share
     parameters with the dygraph model.
-    
-    All TracedLayer objects should not be created by constructor and should 
+
+    All TracedLayer objects should not be created by constructor and should
     be created by static method :code:`TracedLayer.trace(layer, inputs)` .
 
     The TracedLayer can only be used to convert the data-independent dygraph
@@ -159,7 +161,7 @@ class TracedLayer(object):
     @dygraph_only
     def trace(layer, inputs):
         """
-        This method is the only allowed method to create TracedLayer object. 
+        This method is the only allowed method to create TracedLayer object.
         It would call the :code:`layer(*inputs)` method to run the dygraph
         model and convert it into a static graph model.