basic_api_transformer.py 6.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
# 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.

import astor
16
from paddle.utils import gast
17

18
from .static_analysis import (
19 20
    AstNodeWrapper,
)
21
from . import utils
22
from .base_transformer import (
23 24
    BaseTransformer,
)
25

26 27
__all__ = []

28

29
class BasicApiTransformer(BaseTransformer):
30 31 32 33 34 35 36 37 38 39 40 41 42 43
    """
    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 transform(self):
44 45
        to_tensor_transformer = ToTensorTransformer(self.root)
        to_tensor_transformer.transform()
46 47
        attribute_transformer = AttributeJstTransformer(self.root)
        attribute_transformer.transform()
48
        self.visit(self.root)
49

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
        return self.wrapper_root

    def visit_Assign(self, node):
        if self._update_class_node_dict(node):
            return None

        for child_node in gast.walk(node.value):
            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):
                # TODO(liym27):
                #  Considers that a dygraph api which modifies the input or has a output.
67
                if utils.is_dygraph_api(child_node):
68 69 70 71 72 73 74 75 76 77 78
                    return
                else:
                    self._visit_Call(child_node)
        return node

    def _visit_Call(self, node):
        assert isinstance(node, gast.Call)
        func_name = astor.to_source(gast.gast_to_ast(node.func))

        if self._is_dygraph_forward(func_name):
            class_node = self._get_class_node(func_name)
79
            static_node = utils.to_static_ast(node, class_node)
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
            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

97
            if utils.is_dygraph_api(node_value):
98
                dygraph_api = node_value.func.attr
99
                if not utils.dygraph_class_to_static_api.get(dygraph_api):
100 101
                    return False

102
                utils.update_args_of_func(node_value, node_value, "__init__")
103 104 105 106 107
                target_str = astor.to_source(gast.gast_to_ast(node.targets[0]))
                self.class_node_dict[target_str] = node_value
                return True
            # TODO: node.value is not dygraph class
        return False
108 109


110
class ToTensorTransformer(BaseTransformer):
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
    """
    Class to transform paddle.to_tensor and paddle.to_variable to paddle.assign
    """

    def __init__(self, node):
        assert isinstance(
            node, gast.AST
        ), "Input non-gast.AST node for the initialization of ToTensorTransformer."
        self.root = node

    def transform(self):
        self.visit(self.root)
        return self.root

    def visit_Call(self, node):
        assert isinstance(node, gast.Call)
        if is_to_variable(node):
            node = to_assign_node(node)
        self.generic_visit(node)
        return node


133 134 135 136 137 138 139 140 141 142 143 144 145 146
class AttributeJstTransformer(BaseTransformer):
    """
    change some special attribute into __jst.XXX(obj, "attr_name") format.
    for example:
        a.size  -->  __jst.attr(a, "size")

    because `size` have different behavier when in dygraph / static mode
    NOTE: we only deal with ctx=Load() case.
    """

    def __init__(self, node):
        assert isinstance(
            node, gast.AST
        ), "Input non-gast.AST node for the initialization of ToTensorTransformer."
147 148 149 150 151
        self.interested_name = set(
            [
                'size',
            ]
        )
152 153 154 155 156 157 158 159 160
        self.root = node

    def transform(self):
        self.visit(self.root)
        return self.root

    def visit_Attribute(self, node):
        assert isinstance(node, gast.Attribute)
        assert isinstance(node.attr, str)
161 162 163 164
        if (
            isinstance(node.ctx, gast.Load)
            and node.attr in self.interested_name
        ):
165 166
            attr = node.attr
            value = node.value
167 168 169
            node = (
                gast.parse(
                    "_jst.Attr({}, \"{}\")".format(
170
                        utils.ast_to_source_code(value).strip(), attr
171 172 173 174 175
                    )
                )
                .body[0]
                .value
            )
176 177 178 179
        self.generic_visit(node)
        return node


180 181 182 183 184 185 186 187 188 189 190
def is_to_variable(node):
    assert isinstance(node, gast.Call)
    api_name = utils.ast_to_source_code(node.func).strip()

    if utils.is_dygraph_api(node):
        return api_name.endswith("to_variable")

    return False


def to_assign_node(node):
191
    # Transform dygraph api `fluid.dygraph.to_variable` alias `paddle.to_tensor` to static api `paddle.assign`.
192 193 194 195 196 197
    # NOTE:
    #   1. Api `to_variable` supports data type {float16, float32, float64, int16, int32, int64, uint8, uint16},
    #   but api `assign` only supports {float32, float64, int32, int64, bool};
    #   2. If the input of api `assign` is numpy.ndarray, its size cannot be greater than 1024 * 1024.

    assert isinstance(node, gast.Call)
198
    assign_api = gast.parse('paddle.assign').body[0].value
199 200 201 202 203 204 205 206
    node.func = assign_api

    if node.args:
        node.args = [node.args[0]]
        node.keywords = []
    else:
        for idx, kw in enumerate(node.keywords):
            if kw.arg == 'value' or kw.arg == 'data':
207
                node.keywords[idx].arg = 'x'
208 209 210 211
                node.keywords = [node.keywords[idx]]
                node.args = []
                break
    return node