Merge pull request #405 from SunAhong1993/syf_dev

add pytorch code and docs

README.md

@@ -44,6 +44,10 @@ x2paddle --framework=caffe --prototxt=deploy.prototxt --weight=deploy.caffemodel
 ```
 x2paddle --framework=onnx --model=onnx_model.onnx --save_dir=pd_model
 ```
+### PyTorch
+```
+x2paddle --framework=pytorch --model=resnet50.pt --save_dir=pd_model --input_shapes [-1,3,224,224]
+```
 ### Paddle2ONNX
 ```
 # 注意：paddle_infer_model_dir下需包含__model__和__params__两个文件
@@ -52,7 +56,7 @@ x2paddle --framework=paddle2onnx --model=paddle_infer_model_dir --save_dir=onnx_
 ### 参数选项
 | 参数 | |
 |----------|--------------|
-|--framework | 源模型类型 (tensorflow、caffe、onnx、paddle2onnx) |
+|--framework | 源模型类型 (tensorflow、caffe、onnx、pytorch、paddle2onnx) |
 |--prototxt | 当framework为caffe时，该参数指定caffe模型的proto文件路径 |
 |--weight | 当framework为caffe时，该参数指定caffe模型的参数文件路径 |
 |--save_dir | 指定转换后的模型保存目录路径 |
@@ -62,6 +66,7 @@ x2paddle --framework=paddle2onnx --model=paddle_infer_model_dir --save_dir=onnx_
 |--define_input_shape | **[可选]** For TensorFlow, 当指定该参数时，强制用户输入每个Placeholder的shape，见[文档Q2](FAQ.md) |
 |--params_merge | **[可选]** 当指定该参数时，转换完成后，inference_model中的所有模型参数将合并保存为一个文件__params__ |
 |--onnx_opset | **[可选]** 当framework为paddle2onnx时，该参数可设置转换为ONNX的OpSet版本，目前支持9、10、11，默认为10 |
+|--input_shapes |**[可选]** 当framework为pytorch时，该参数若设置，则根据输入的shape导出inference model（用于预测的静态模型）|
 
 
 

pytorch_to_script.md

+## PyTorch模型导出为ONNX模型
+
+目前pytorch2paddle主要支持pytorch ScriptModule。 用户可通过如下示例代码，将torchvison或者自己开发写的模型转换成ScriptModule model:
+```
+#coding: utf-8
+import torch
+import torch.nn as nn
+from torchvision.models.utils import load_state_dict_from_url
+# 定义模型
+class AlexNet(nn.Module):
+    def __init__(self, num_classes=1000):
+        super(AlexNet, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(64, 192, kernel_size=5, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(192, 384, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(384, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+        )
+        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
+        self.classifier = nn.Sequential(
+            nn.Dropout(0.0),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.0),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            nn.Linear(4096, num_classes),
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        for i in range(1):
+            x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x
+# 初始化模型
+model = AlexNet()
+# 加载参数
+state_dict = load_state_dict_from_url('https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth',
+                                      progress=True)
+model.load_state_dict(state_dict)
+# 设置模式
+model.eval()
+# 生成ScriptModule并保存
+script = torch.jit.script(model)
+torch.jit.save(script, "alexnet.pt")
+```

x2paddle/__init__.py

 __version__ = "0.8.4"
 
-from .core.program import PaddleProgram
+from .core.program import PaddleGraph
 
-program = PaddleProgram()
+program = PaddleGraph()
 
 name_counter = dict()
 

x2paddle/convert.py

@@ -87,10 +87,14 @@ def arg_parser():
         action="store_true",
         default=False,
         help="define whether merge the params")
-
+    parser.add_argument(
+        "--input_shapes",
+        "-is",
+        action='append',
+        default=None,
+        help="define the inputs' shape")
     return parser
 
-
 def tf2paddle(model_path,
               save_dir,
               without_data_format_optimization,
@@ -190,6 +194,45 @@ def onnx2paddle(model_path, save_dir, params_merge=False):
     print("Paddle model and code generating ...")
     mapper.save_inference_model(save_dir, params_merge)
     print("Paddle model and code generated.")
+    
+    
+def pytorch2paddle(model_path, save_dir, input_shapes):
+    # check pytorch installation and version
+    try:
+        import torch
+        version = torch.__version__
+        ver_part = version.split('.')
+        print(ver_part)
+        if int(ver_part[1]) < 5:
+            print("[ERROR] pytorch>=1.5.0 is required")
+            return
+    except:
+        print(
+            "[ERROR] Pytorch is not installed, use \"pip install torch==1.5.0 torchvision\"."
+        )
+        return
+    print("Now translating model from pytorch to paddle.")
+
+    from x2paddle.decoder.pytorch_decoder import PyTorchDecoder
+    from x2paddle.op_mapper.pytorch2paddle import pytorch_op_mapper
+    model = PyTorchDecoder(model_path)
+    mapper = pytorch_op_mapper.PyTorchOpMapper(model)
+    mapper.graph.build()
+    print("Model optimizing ...")
+    from x2paddle.optimizer.pytorch_optimizer.optimizer import GraphOptimizer
+    graph_opt = GraphOptimizer()
+    graph_opt.optimize(mapper.graph)
+    print("Model optimized.")
+    if input_shapes is not None:
+        real_input_shapes = list()
+        for shape in input_shapes:
+            sp = shape[1:-1].split(",")
+            for i, s in enumerate(sp):
+                sp[i] = int(s)
+            real_input_shapes.append(sp)
+    else:
+        real_input_shapes = None
+    mapper.graph.gen_model(save_dir, real_input_shapes)
 
 
 def paddle2onnx(model_path, save_dir, opset_version=10):
@@ -267,6 +310,10 @@ def main():
         if args.params_merge:
             params_merge = True
         onnx2paddle(args.model, args.save_dir, params_merge)
+        
+    elif args.framework == "pytorch":
+        assert args.model is not None, "--model should be defined while translating pytorch model"
+        pytorch2paddle(args.model, args.save_dir, args.input_shapes)
 
     elif args.framework == "paddle2onnx":
         assert args.model is not None, "--model should be defined while translating paddle model to onnx"
@@ -278,4 +325,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()
\ No newline at end of file

x2paddle/decoder/pytorch_decoder.py

+#   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
+
+
+class PyTorchDecoder(object):
+    def __init__(self, script_path):
+        self.script = torch.jit.load(script_path)
+        self.graph = self._optimize_graph(self.script.inlined_graph)
+
+    def _optimize_graph(self, graph):
+        torch._C._jit_pass_constant_propagation(graph)
+        torch._C._jit_pass_dce(graph)
+        torch._C._jit_pass_lint(graph)
+        torch._C._jit_pass_peephole(graph)
+        torch._C._jit_pass_lint(graph)
+        torch._C._jit_pass_dce(graph)
+        torch._C._jit_pass_lint(graph)
+        torch._C._jit_pass_canonicalize(graph)
+        torch._C._jit_pass_lint(graph)
+        torch._C._jit_pass_constant_propagation(graph)
+        return graph

x2paddle/optimizer/pytorch_optimizer/fusion/__init__.py

+#   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 .adaptive_pool2d_fuser import AdaptivePool2dFuser
+from .adaptive_pool2d_fuse_pass import AdaptivePool2dFusePass
+from .batchnorm2d_fuser import BatchNorm2dFuser
+from .batchnorm2d_fuse_pass import BatchNorm2dFusePass
+from .constant_fuser import ConstantFuser
+from .constant_fuse_pass import ConstantFusePass
+from .dropout_fuser import DropoutFuser
+from .dropout_fuse_pass import DropoutFusePass
+from .fc_fuser import FcFuser
+from .fc_fuse_pass import FcFusePass
+from .interpolate_bilinear_fuser import InterpolateBilinearFuser
+from .interpolate_bilinear_fuse_pass import InterpolateBilinearFusePass
+from .reshape_fuser import ReshapeFuser
+from .reshape_fuse_pass import ReshapeFusePass

x2paddle/optimizer/pytorch_optimizer/fusion/adaptive_pool2d_fuse_pass.py

+#   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 x2paddle.optimizer.pytorch_optimizer.pass_ import Pass
+from x2paddle.optimizer.pytorch_optimizer.fusion import AdaptivePool2dFuser
+from x2paddle.optimizer.pytorch_optimizer.pass_manager import pass_register
+
+
+@pass_register
+class AdaptivePool2dFusePass(Pass):
+    name = "adaptive_pool2d_fuse_pass"
+
+    def __init__(self):
+        Pass.__init__(self)
+
+    def apply(self, graph):
+        fuser = AdaptivePool2dFuser()
+        fuser.operate(graph, match_kind="topo")
+
+
+# 用于注册
+adaptive_pool2d_fuse_pass = AdaptivePool2dFusePass()

x2paddle/optimizer/pytorch_optimizer/fusion/batchnorm2d_fuse_pass.py

+#   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 x2paddle.optimizer.pytorch_optimizer.pass_ import Pass
+from x2paddle.optimizer.pytorch_optimizer.fusion import BatchNorm2dFuser
+from x2paddle.optimizer.pytorch_optimizer.pass_manager import pass_register
+
+
+@pass_register
+class BatchNorm2dFusePass(Pass):
+    name = "batchnorm2d_fuse_pass"
+
+    def __init__(self):
+        Pass.__init__(self)
+
+    def apply(self, graph):
+        fuser = BatchNorm2dFuser()
+        fuser.operate(graph, match_kind="topo")
+
+
+# 用于注册
+batchnorm2d_fuse_pass = BatchNorm2dFusePass()

x2paddle/optimizer/pytorch_optimizer/fusion/constant_fuse_pass.py

+#   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 x2paddle.optimizer.pytorch_optimizer.pass_ import Pass
+from x2paddle.optimizer.pytorch_optimizer.fusion import ConstantFuser
+from x2paddle.optimizer.pytorch_optimizer.pass_manager import pass_register
+
+
+@pass_register
+class ConstantFusePass(Pass):
+    name = "constant_fuse_pass"
+
+    def __init__(self):
+        Pass.__init__(self)
+
+    def apply(self, graph):
+        fuser = ConstantFuser()
+        fuser.operate(graph, match_kind="topo")
+
+
+# 用于注册
+constant_fuse_pass = ConstantFuser()