!10095 modify export file to support mindir and support GPU

From: @yuzhenhua666
Reviewed-by: @c_34,@linqingke,@wuxuejian
Signed-off-by: @c_34

model_zoo/official/cv/efficientnet/export.py

@@ -0,0 +1,53 @@
+# Copyright 2020 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+"""export file"""
+import argparse
+import numpy as np
+
+from mindspore import Tensor, context, load_checkpoint, load_param_into_net, export
+from src.efficientnet import efficientnet_b0
+from src.config import efficientnet_b0_config_gpu as cfg
+
+parser = argparse.ArgumentParser(description="efficientnet export")
+parser.add_argument("--device_id", type=int, default=0, help="Device id")
+parser.add_argument("--width", type=int, default=224, help="input width")
+parser.add_argument("--height", type=int, default=224, help="input height")
+parser.add_argument("--ckpt_file", type=str, required=True, help="Checkpoint file path.")
+parser.add_argument("--file_name", type=str, default="efficientnet", help="output file name.")
+parser.add_argument("--file_format", type=str, choices=["AIR", "ONNX", "MINDIR"],
+                    default="MINDIR", help="file format")
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="GPU",
+                    help="device target")
+args = parser.parse_args()
+
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
+
+if __name__ == "__main__":
+    if args.platform != "GPU":
+        raise ValueError("Only supported GPU now.")
+
+    net = efficientnet_b0(num_classes=cfg.num_classes,
+                          drop_rate=cfg.drop,
+                          drop_connect_rate=cfg.drop_connect,
+                          global_pool=cfg.gp,
+                          bn_tf=cfg.bn_tf,
+                          )
+
+    ckpt = load_checkpoint(args.ckpt_file)
+    load_param_into_net(net, ckpt)
+    net.set_train(False)
+
+    image = Tensor(np.ones([cfg.batch_size, 3, args.height, args.width], np.float32))
+    export(net, image, file_name=args.file_name, file_format=args.file_format)

model_zoo/official/cv/squeezenet/export.py

@@ -13,42 +13,45 @@
 # limitations under the License.
 # ============================================================================
 """
-##############export checkpoint file into air and onnx models#################
+##############export checkpoint file into air , mindir and onnx models#################
 python export.py --net squeezenet --dataset cifar10 --checkpoint_path squeezenet_cifar10-120_1562.ckpt
 """
 
 import argparse
 import numpy as np
-from mindspore import Tensor
+from mindspore import context, Tensor, load_checkpoint, load_param_into_net, export
-from mindspore.train.serialization import load_checkpoint, load_param_into_net, export
+
+parser = argparse.ArgumentParser(description='checkpoint export')
+parser.add_argument("--device_id", type=int, default=0, help="Device id")
+parser.add_argument("--batch_size", type=int, default=32, help="batch size")
+parser.add_argument("--ckpt_file", type=str, required=True, help="Checkpoint file path.")
+parser.add_argument('--width', type=int, default=227, help='input width')
+parser.add_argument('--height', type=int, default=227, help='input height')
+parser.add_argument('--net', type=str, default='squeezenet', choices=['squeezenet', 'squeezenet_residual'],
+                    help='Model.')
+parser.add_argument('--dataset', type=str, default='cifar10', choices=['cifar10', 'imagenet'], help='Dataset.')
+parser.add_argument("--file_name", type=str, default="squeezenet", help="output file name.")
+parser.add_argument("--file_format", type=str, choices=["AIR", "ONNX", "MINDIR"], default="AIR", help="file format")
+parser.add_argument("--device_target", type=str, default="Ascend",
+                    choices=["Ascend", "GPU", "CPU"], help="device target (default: Ascend)")
+args = parser.parse_args()
+
+if args.net == "squeezenet":
+    from src.squeezenet import SqueezeNet as squeezenet
+else:
+    from src.squeezenet import SqueezeNet_Residual as squeezenet
+if args.dataset == "cifar10":
+    num_classes = 10
+else:
+    num_classes = 1000
+
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
 
 if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Image classification')
-    parser.add_argument('--net', type=str, default='squeezenet', choices=['squeezenet', 'squeezenet_residual'],
-                        help='Model.')
-    parser.add_argument('--dataset', type=str, default='cifar10', choices=['cifar10', 'imagenet'], help='Dataset.')
-    parser.add_argument('--checkpoint_path', type=str, default=None, help='Checkpoint file path')
-    args_opt = parser.parse_args()
-
-    if args_opt.net == "squeezenet":
-        from src.squeezenet import SqueezeNet as squeezenet
-    else:
-        from src.squeezenet import SqueezeNet_Residual as squeezenet
-    if args_opt.dataset == "cifar10":
-        num_classes = 10
-    else:
-        num_classes = 1000
-
-    onnx_filename = args_opt.net + '_' + args_opt.dataset
-    air_filename = args_opt.net + '_' + args_opt.dataset
-
     net = squeezenet(num_classes=num_classes)
 
-    assert args_opt.checkpoint_path is not None, "checkpoint_path is None."
+    param_dict = load_checkpoint(args.ckpt_file)
-
-    param_dict = load_checkpoint(args_opt.checkpoint_path)
     load_param_into_net(net, param_dict)
 
-    input_arr = Tensor(np.zeros([1, 3, 227, 227], np.float32))
+    input_data = Tensor(np.zeros([args.batch_size, 3, args.height, args.width], np.float32))
-    export(net, input_arr, file_name=onnx_filename, file_format="ONNX")
+    export(net, input_data, file_name=args.file_name, file_format=args.file_format)
-    export(net, input_arr, file_name=air_filename, file_format="AIR")

model_zoo/official/cv/ssd/export.py

@@ -28,9 +28,11 @@ parser.add_argument("--batch_size", type=int, default=1, help="batch size")
 parser.add_argument("--ckpt_file", type=str, required=True, help="Checkpoint file path.")
 parser.add_argument("--file_name", type=str, default="ssd", help="output file name.")
 parser.add_argument('--file_format', type=str, choices=["AIR", "ONNX", "MINDIR"], default='AIR', help='file format')
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
 args = parser.parse_args()
 
-context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", device_id=args.device_id)
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
 
 if __name__ == '__main__':
     if config.model == "ssd300":

model_zoo/official/cv/unet/export.py

@@ -16,20 +16,30 @@
 import argparse
 import numpy as np
 
-from mindspore import Tensor, export, load_checkpoint, load_param_into_net
+from mindspore import Tensor, export, load_checkpoint, load_param_into_net, context
 
 from src.unet.unet_model import UNet
+from src.config import cfg_unet as cfg
 
-parser = argparse.ArgumentParser(description='Export ckpt to air')
+parser = argparse.ArgumentParser(description='unet export')
-parser.add_argument('--ckpt_file', type=str, default="ckpt_unet_medical_adam-1_600.ckpt",
+parser.add_argument("--device_id", type=int, default=0, help="Device id")
-                    help='The path of input ckpt file')
+parser.add_argument("--batch_size", type=int, default=1, help="batch size")
-parser.add_argument('--air_file', type=str, default="unet_medical_adam-1_600", help='The path of output air file')
+parser.add_argument("--ckpt_file", type=str, required=True, help="Checkpoint file path.")
+parser.add_argument('--width', type=int, default=572, help='input width')
+parser.add_argument('--height', type=int, default=572, help='input height')
+parser.add_argument("--file_name", type=str, default="unet", help="output file name.")
+parser.add_argument('--file_format', type=str, choices=["AIR", "ONNX", "MINDIR"], default='AIR', help='file format')
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
 args = parser.parse_args()
 
-net = UNet(n_channels=1, n_classes=2)
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
-# return a parameter dict for model
+
-param_dict = load_checkpoint(args.ckpt_file)
+if __name__ == "__main__":
-# load the parameter into net
+    net = UNet(n_channels=cfg["num_channels"], n_classes=cfg["num_classes"])
-load_param_into_net(net, param_dict)
+    # return a parameter dict for model
-input_data = np.random.uniform(0.0, 1.0, size=[1, 1, 572, 572]).astype(np.float32)
+    param_dict = load_checkpoint(args.ckpt_file)
-export(net, Tensor(input_data), file_name=args.air_file, file_format='AIR')
+    # load the parameter into net
+    load_param_into_net(net, param_dict)
+    input_data = Tensor(np.ones([args.batch_size, cfg["num_channels"], args.height, args.width]).astype(np.float32))
+    export(net, input_data, file_name=args.file_name, file_format=args.file_format)

model_zoo/official/cv/vgg16/export.py

@@ -22,13 +22,14 @@ from mindspore.train.serialization import load_checkpoint, export
 
 from src.vgg import vgg16
 
-context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
-
 parser = argparse.ArgumentParser(description='VGG16 export')
+parser.add_argument("--device_id", type=int, default=0, help="Device id")
 parser.add_argument('--dataset', type=str, choices=["cifar10", "imagenet2012"], default="cifar10", help='ckpt file')
 parser.add_argument('--ckpt_file', type=str, required=True, help='vgg16 ckpt file.')
-parser.add_argument('--output_file', type=str, default='vgg16', help='vgg16 output air name.')
+parser.add_argument('--file_name', type=str, default='vgg16', help='vgg16 output file name.')
 parser.add_argument('--file_format', type=str, choices=["AIR", "ONNX", "MINDIR"], default='AIR', help='file format')
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
 args = parser.parse_args()
 
 if args.dataset == "cifar10":
@@ -45,6 +46,7 @@ args.batch_norm = cfg.batch_norm
 args.has_dropout = cfg.has_dropout
 args.image_size = list(map(int, cfg.image_size.split(',')))
 
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
 
 if __name__ == '__main__':
     if args.dataset == "cifar10":
@@ -58,4 +60,4 @@ if __name__ == '__main__':
 
     input_data = Tensor(np.zeros([cfg.batch_size, 3, args.image_size[0], args.image_size[1]]), mstype.float32)
 
-    export(net, input_data, file_name=args.output_file, file_format=args.file_format)
+    export(net, input_data, file_name=args.file_name, file_format=args.file_format)

model_zoo/official/cv/warpctc/export.py

@@ -21,22 +21,26 @@ from mindspore import Tensor, context, load_checkpoint, load_param_into_net, exp
 from src.warpctc import StackedRNN
 from src.config import config
 
-context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+parser = argparse.ArgumentParser(description="warpctc_export")
+parser.add_argument("--device_id", type=int, default=0, help="Device id")
+parser.add_argument("--ckpt_file", type=str, required=True, help="warpctc ckpt file.")
+parser.add_argument("--file_name", type=str, default="warpctc", help="warpctc output file name.")
+parser.add_argument("--file_format", type=str, choices=["AIR", "ONNX", "MINDIR"], default="MINDIR", help="file format")
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
+args = parser.parse_args()
 
-if __name__ == '__main__':
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
 
-    parser = argparse.ArgumentParser(description='warpctc_export')
+if __name__ == "__main__":
-    parser.add_argument('--ckpt_file', type=str, default='', help='warpctc ckpt file.')
-    parser.add_argument('--output_file', type=str, default='', help='warpctc output air name.')
-    args_opt = parser.parse_args()
     captcha_width = config.captcha_width
     captcha_height = config.captcha_height
     batch_size = config.batch_size
     hidden_size = config.hidden_size
     net = StackedRNN(captcha_height * 3, batch_size, hidden_size)
-    param_dict = load_checkpoint(args_opt.ckpt_file)
+    param_dict = load_checkpoint(args.ckpt_file)
     load_param_into_net(net, param_dict)
     net.set_train(False)
 
     image = Tensor(np.zeros([batch_size, 3, captcha_height, captcha_width], np.float16))
-    export(net, image, file_name=args_opt.output_file, file_format="AIR")
+    export(net, image, file_name=args.file_name, file_format=args.file_format)

model_zoo/official/cv/xception/export.py

@@ -0,0 +1,48 @@
+# Copyright 2020 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+"""eval Xception."""
+import argparse
+import numpy as np
+
+from mindspore import Tensor, context, load_checkpoint, load_param_into_net, export
+
+from src.Xception import xception
+from src.config import config
+
+parser = argparse.ArgumentParser(description="Image classification")
+parser.add_argument("--device_id", type=int, default=0, help="Device id")
+parser.add_argument("--ckpt_file", type=str, required=True, help="xception ckpt file.")
+parser.add_argument("--width", type=int, default=299, help="input width")
+parser.add_argument("--height", type=int, default=299, help="input height")
+parser.add_argument("--file_name", type=str, default="xception", help="xception output file name.")
+parser.add_argument("--file_format", type=str, choices=["AIR", "ONNX", "MINDIR"],
+                    default="MINDIR", help="file format")
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
+args = parser.parse_args()
+
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
+
+if __name__ == "__main__":
+    # define net
+    net = xception(class_num=config.class_num)
+
+    # load checkpoint
+    param_dict = load_checkpoint(args.ckpt_file)
+    load_param_into_net(net, param_dict)
+    net.set_train(False)
+
+    image = Tensor(np.zeros([config.batch_size, 3, args.height, args.width], np.float32))
+    export(net, image, file_name=args.file_name, file_format=args.file_format)

model_zoo/official/cv/yolov3_darknet53/export.py

@@ -22,15 +22,17 @@ from mindspore.train.serialization import export, load_checkpoint, load_param_in
 from src.yolo import YOLOV3DarkNet53
 from src.config import ConfigYOLOV3DarkNet53
 
-parser = argparse.ArgumentParser(description='yolov3_darknet53 export')
+parser = argparse.ArgumentParser(description="yolov3_darknet53 export")
 parser.add_argument("--device_id", type=int, default=0, help="Device id")
 parser.add_argument("--batch_size", type=int, default=1, help="batch size")
 parser.add_argument("--ckpt_file", type=str, required=True, help="Checkpoint file path.")
 parser.add_argument("--file_name", type=str, default="yolov3_darknet53", help="output file name.")
-parser.add_argument('--file_format', type=str, choices=["AIR", "ONNX", "MINDIR"], default='AIR', help='file format')
+parser.add_argument("--file_format", type=str, choices=["AIR", "ONNX", "MINDIR"], default="AIR", help="file format")
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
 args = parser.parse_args()
 
-context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", device_id=args.device_id)
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
 
 if __name__ == "__main__":
     network = YOLOV3DarkNet53(is_training=False)

model_zoo/official/cv/yolov3_resnet18/export.py

@@ -28,9 +28,11 @@ parser.add_argument("--batch_size", type=int, default=1, help="batch size")
 parser.add_argument("--ckpt_file", type=str, required=True, help="Checkpoint file path.")
 parser.add_argument("--file_name", type=str, default="yolov3_resnet18", help="output file name.")
 parser.add_argument('--file_format', type=str, choices=["AIR", "ONNX", "MINDIR"], default='AIR', help='file format')
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
 args = parser.parse_args()
 
-context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", device_id=args.device_id)
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
 
 if __name__ == "__main__":
     config = ConfigYOLOV3ResNet18()

model_zoo/official/cv/yolov4/export.py

@@ -28,9 +28,11 @@ parser.add_argument("--testing_shape", type=int, default=608, help="test shape")
 parser.add_argument("--ckpt_file", type=str, required=True, help="Checkpoint file path.")
 parser.add_argument("--file_name", type=str, default="yolov4", help="output file name.")
 parser.add_argument('--file_format', type=str, choices=["AIR", "ONNX", "MINDIR"], default='AIR', help='file format')
+parser.add_argument("--device_target", type=str, choices=["Ascend", "GPU", "CPU"], default="Ascend",
+                    help="device target")
 args = parser.parse_args()
 
-context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", device_id=args.device_id)
+context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target, device_id=args.device_id)
 
 if __name__ == "__main__":
     ts_shape = args.testing_shape