pytorch_op_mapper.py

# -*- coding:UTF-8 -*-
#   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 torch
import numpy as np
from x2paddle.core.op_mapper import OpMapper
from x2paddle.core.util import *
from x2paddle.core.program import PaddleGraph
from x2paddle.op_mapper.dygraph.pytorch2paddle import prim
from x2paddle.op_mapper.dygraph.pytorch2paddle import aten


class PyTorchOpMapper(OpMapper):
    def __init__(self, decoder):
        super(PyTorchOpMapper, self).__init__()
        self.script = decoder.script
        self.input_examples = decoder.input_examples
        self.paddle_params = dict()
        self.outputs_info = {}  # key为output unique id，value为当前节点的输出名字
        self.pytorch_params = {}  # key为节点名，value为参数
        self.attrs = {}  # key为节点名，value为属性值
        self.output_index = 0
        self.nn_name2id = {}  # 动态图__init__输出名字中的id，key为kernel类型，value为id
        self.split_len = {}  # split的长度
        self.scope_name_list = list()
        self.scope_name2id = dict()
        self.inputs_info = dict()
        self.output2id = dict()  # output名字和layer_id的关系，用于lstm去除前面的node
        # 转换
        if not self.op_checker(decoder.graph):
            raise Exception("Model is not supported yet.")
        self.paddle_graph, _ = self.traverse(decoder.graph)
        self.paddle_graph.set_inputs_info(self.inputs_info)

    def op_checker(self, script_graph):
        def _update_op_list(graph):
            for node in graph.nodes():
                op_list.append(node.kind())
                for block in node.blocks():
                    _update_op_list(block)

        op_list = list()
        _update_op_list(script_graph)
        op_list = list(set(op_list))
        unsupported_ops = []
        for op in op_list:
            func_name = op.replace('::', '_')
            if not (hasattr(prim, func_name) or hasattr(aten, func_name)):
                unsupported_ops.append(op)
        if len(unsupported_ops) == 0:
            return True
        else:
            if len(unsupported_ops) > 0:
                print("\n========= {} OPs are not supported yet ===========".
                      format(len(unsupported_ops)))
            for op in unsupported_ops:
                print("========== {} ============".format(op))
            return False

    def traverse(self, script_graph, parent_layer=None):
        # 用于获取graph的输入
        def _update_graph_inputs(kind, inputs, outputs):
            # extend只能放更新graph_inputs之前的情况：
            # 1. loop的输出i也是输入；i是输入的原因是：子图中为父图得到的。
            # 2. 在_check_input中需要使用to_variable。
            # extend只能放更新graph_inputs之后的情况：
            # 使用了append。
            if kind != "aten::append":
                current_node_outputs.extend(outputs)
            for name in inputs:
                if name not in current_node_outputs:
                    graph_inputs.append(name)
            if kind == "aten::append":
                current_node_outputs.extend(outputs)

        # 初始化
        graph = PaddleGraph(
            source_type="pytorch",
            parent_layer=parent_layer,
            graph_type="dygraph")
        if "TopLevelTracedModule" in str(type(self.script)):
            graph.set_script(self.script)
        current_node_outputs = []
        graph_inputs = []
        # 转换输入节点
        if isinstance(script_graph, torch._C.Graph):
            input_ct = 0
            for i, ivalue in enumerate(script_graph.inputs()):
                node = ivalue.node()
                if str(ivalue.type()) not in ["Tensor", "Dict[str, Tensor]"]:
                    graph.set_name(str(ivalue.type()).split(".")[-1])
                    continue
                inputs, outputs = self.data(graph, node,
                                            ivalue.unique(), input_ct)
                input_ct += 1
        # 转换中间节点
        for node in script_graph.nodes():
            kind = node.kind()
            func_name = kind.replace('::', '_')
            if hasattr(prim, func_name):
                func = getattr(prim, func_name)
                inputs, outputs = func(self, graph, node)
                _update_graph_inputs(kind, inputs, outputs)
            elif hasattr(aten, func_name):
                func = getattr(aten, func_name)
                inputs, outputs = func(self, graph, node)
                _update_graph_inputs(kind, inputs, outputs)

        # 转换输出节点
        if hasattr(script_graph, 'returnNode'):
            for i, ivalue in enumerate(script_graph.returnNode().inputs()):
                if parent_layer.kernel == "prim.loop" and i == 0:
                    continue
                node = ivalue.node()
                script_unique_id = ivalue.unique()
                inputs, outputs = self.equal(
                    graph,
                    node,
                    uid=script_unique_id,
                    parent_layer=parent_layer,
                    index=i)
                _update_graph_inputs("equal", inputs, outputs)

        # 设置graph的参数和输出节点
        if isinstance(script_graph, torch._C.Graph):
            graph.set_parameters(self.paddle_params)
            if hasattr(script_graph, 'return_node'):
                inputs_name, inputs_node = self._get_inputs_name(
                    script_graph.return_node())
                graph.outputs = inputs_name
        # 更新split参数
        for layer in graph.layers.values():
            if layer.kernel == "paddle.split" and "num_or_sections" in layer.attrs \
            and not isinstance(layer.attrs["num_or_sections"], int) and len(set(layer.attrs["num_or_sections"])) == 1:
                layer.attrs["num_or_sections"] = self.split_len[layer.outputs[
                    0]]
        return graph, graph_inputs

    def _get_outputs_name(self, node, attr_name=None):
        outputs_name = []
        for output_ivalue in node.outputs():
            script_unique_id = output_ivalue.unique()
            if attr_name is None:
                output_name = 'x' + str(self.output_index)
                if script_unique_id in self.outputs_info:
                    output_name = self.outputs_info[script_unique_id]
            else:
                output_name = attr_name.replace(".", "_")
            self.outputs_info[script_unique_id] = output_name
            self.output_index += 1

            outputs_name.append(output_name)
        # if或loop节点没有输出的情况
        if len(list(node.outputs())) == 0:
            output_name = '_x' + str(self.output_index)
            self.output_index += 1
            outputs_name.append(output_name)
        return outputs_name

    def _check_input(self,
                     graph,
                     node,
                     output_name,
                     node_outputs,
                     scope_name,
                     add_dim=False):
        if node.kind() == "prim::GetAttr":
            param = self.pytorch_params[output_name]
            if isinstance(param, np.ndarray):
                if add_dim:
                    param = param[np.newaxis, :]
                self.paddle_params[output_name] = param
                layer_id = graph.add_layer(
                    "self.create_parameter",
                    inputs={},
                    outputs=[output_name],
                    scope_name=scope_name,
                    dtype=string(str(param.dtype)),
                    shape=param.shape,
                    default_initializer="paddle.nn.initializer.Constant(value=0.0)"
                )
                self.output2id[output_name] = layer_id
            else:
                if isinstance(param, dict) and "Tensor" in param and \
                "parent_layer_id" in param:
                    if graph.parent_layer is not None:
                        # 当某个param被2个控制流（if-else）赋值时，else不可以引用if中的赋值结果
                        id1 = param["parent_layer_id"]
                        id2 = graph.parent_layer.id
                        id1_part = id1.split(".")
                        id2_part = id2.split(".")
                        if len(id1_part) >= len(id2_part):
                            for i in range(len(id1_part)):
                                if id1_part[i] == id2_part[i]:
                                    continue
                                else:
                                    if id1_part[i] == "0" and id2_part[
                                            i] == "1":
                                        if add_dim:
                                            param = param[np.newaxis, :]
                                        self.paddle_params[output_name] = param
                                        layer_id = graph.add_layer(
                                            "self.create_parameter",
                                            inputs={},
                                            outputs=[output_name],
                                            scope_name=scope_name,
                                            dtype=string(str(param.dtype)),
                                            shape=param.shape,
                                            default_initializer="paddle.nn.initializer.Constant(value=0.0)"
                                        )
                                        node_outputs.append(output_name)
                                        self.output2id[output_name] = layer_id
                                        return
                    # 若if-else外，则可直接引用if-else中的赋值结果
                    graph.add_layer(
                        "prim.constant",
                        inputs={},
                        outputs=[output_name],
                        scope_name=scope_name,
                        value=param["Tensor"])
                else:
                    graph.add_layer(
                        "prim.constant",
                        inputs={},
                        outputs=[output_name],
                        scope_name=scope_name,
                        value=string(param)
                        if isinstance(param, str) else param)
            node_outputs.append(output_name)
        elif node.kind(
        ) == "prim::Constant" and output_name in self.pytorch_params:
            param = self.pytorch_params[output_name]
            self.paddle_params[output_name] = param
            layer_id = graph.add_layer(
                "self.create_parameter",
                inputs={},
                outputs=[output_name],
                scope_name=scope_name,
                dtype=string(str(param.dtype)),
                shape=param.shape,
                default_initializer="paddle.nn.initializer.Constant(value=0.0)")
            self.output2id[output_name] = layer_id

    def _get_inputs_name(self, node):
        inputs_name = []
        inputs_node = []
        for script_input_ivalue in node.inputs():
            script_input_node = script_input_ivalue.node()
            script_input_unique_id = script_input_ivalue.unique()
            input_name = self.outputs_info[script_input_unique_id]
            inputs_node.append(script_input_node)
            inputs_name.append(input_name)
        return inputs_name, inputs_node

    def data(self, graph, node, uid, input_ct):
        scope_name = self.normalize_scope_name(node)
        for output_ivalue in node.outputs():
            script_unique_id = output_ivalue.unique()
            if script_unique_id in self.outputs_info or script_unique_id != uid:
                continue
            node_name = 'x' + str(self.output_index)
            self.outputs_info[script_unique_id] = node_name
            self.output_index += 1
        output_name = self.outputs_info[uid]
        graph.add_layer(
            "paddle.to_tensor",
            inputs={},
            outputs=[node_name],
            scope_name=scope_name,
            data=output_name)
        if self.input_examples is not None:
            input_np = self.input_examples[input_ct].cpu().detach().numpy()
            self.inputs_info[
                output_name] = [list(input_np.shape), str(input_np.dtype)]
        return [], [output_name]

    def equal(self, graph, node, uid=None, parent_layer=None, index=None):
        scope_name = self.normalize_scope_name(node)
        if parent_layer is not None and index is not None:
            # block的输出
            input_node_name = self.outputs_info[uid]
            control_output_id = index
            if parent_layer.kernel == "prim.loop":
                control_output_id = index - 1
            output_node_name = parent_layer.outputs[control_output_id]
            current_outputs = [output_node_name]
            self._check_input(graph, node, input_node_name, current_outputs,
                              scope_name)
            graph.add_layer(
                "prim.equal",
                inputs={'input': input_node_name},
                outputs=[output_node_name],
                scope_name=scope_name)
            return [input_node_name], current_outputs

    def normalize_scope_name(self, node):
        """ 对scope的名字进行标准化。
        """
        scope_name = node.scopeName()
        if scope_name == "":
            return scope_name
        scope_name_part = scope_name.split("/")
        for index in range(len(scope_name_part) - 1):
            if scope_name_part[index] in scope_name_part[index + 1]:
                continue
            last_name_segments = scope_name_part[index].split(".")
            name_segments = scope_name_part[index + 1].split(".")
            for j, name in enumerate(last_name_segments):
                name_segments[j] = name
            scope_name_part[index + 1] = ".".join(name_segments)
        last_name = scope_name_part[-1]
        name_segments = last_name.split(".")
        for i, ns in enumerate(name_segments):
            if i not in self.scope_name2id:
                self.scope_name2id[i] = dict()
            if ns not in self.scope_name2id[i]:
                self.scope_name2id[i][ns] = 0
        real_scope_name = "/".join(name_segments[1:])
        real_father_scope_name = "/".join(name_segments[1:-1])

        for i, ns in enumerate(name_segments):
            if i == 0:
                continue
            if self.scope_name2id[i][ns] != 0:
                name_segments[i] = name_segments[i] + \
                "__{}".format(self.scope_name2id[i][ns])
            prefix_scope_name = "/".join(name_segments[1:i + 1])
            is_found = False
            for j in range(len(self.scope_name_list)):
                last_scope_name = self.scope_name_list[-1 - j]
                if last_scope_name.startswith(prefix_scope_name + "/") \
                        or last_scope_name == prefix_scope_name:
                    if j != 0:  # and i != len(name_segments) - 1:
                        is_found = True
                        origin_name_segment_i = name_segments[i].split("__")[0]
                        self.scope_name2id[i][origin_name_segment_i] += 1
                        name_segments[i] = origin_name_segment_i + \
                            "__" + str(self.scope_name2id[i][origin_name_segment_i])
                    break
            if is_found:
                break
        real_scope_name = "/".join(name_segments[1:])
        self.scope_name_list.append(real_scope_name)
        return real_scope_name