Update runners

tools/dyn_test_runner.py

@@ -62,7 +62,7 @@ def parse_dyn_dim_str(dim_str):
     # expecting string like: "{1, 4, 2}" or "{2, 4}"
     if dim_str is None:
         return migraphx.shape.dynamic_dimension(1, 1, 0)
-    dim_str = dim_str.strip('{}')
+    dim_str = dim_str.strip('{}()')
     dims = [int(x) for x in dim_str.split(', ')]
     if len(dims) == 3:
         return migraphx.shape.dynamic_dimension(dims[0], dims[1], dims[2])
@@ -71,15 +71,14 @@ def parse_dyn_dim_str(dim_str):
 
 def parse_dyn_dims_str(dds_str):
     # expecting string like "{{1, 4, 2}, {4, 4}, {4, 4}}"
-    dds_str = dds_str.strip('{}')
-    dyn_dims = dds_str.split(', ')
+    dyn_dims = dds_str[1, -2].split(', ')
     return [parse_dyn_dim_str(dd) for dd in dyn_dims]
 
 
 def parse_map_dyn_input_str(dict_str):
     # return {input_name: list<dynamic_dimension>}
     # expecting string like: {"A": {{1, 4, 2}, {4, 4}, {4, 4}}, "B": {{2, 4}, {2, 4}}}
-    dict_str = dict_str.strip('{}')
+    dict_str = dict_str[1, -2]
     pairs = dict_str.split(', ')
     dd_dict = {}
     for p in pairs:

tools/ort_resnet50_run.py

+import argparse
+import numpy as np
+import onnx
+from onnx import numpy_helper
+import onnxruntime as ort
+
+
+def read_pb_file(filename):
+    with open(filename, 'rb') as pfile:
+        data_str = pfile.read()
+        tensor = onnx.TensorProto()
+        tensor.ParseFromString(data_str)
+        np_array = numpy_helper.to_array(tensor)
+
+    return np_array
+
+
+def write_pb_file(data, filename):
+    tensor = numpy_helper.from_array(data)
+    with open(filename + ".pb", "wb") as f:
+        f.write(tensor.SerializeToString())
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Run resnet50 model with input protobuff and write output")
+    parser.add_argument("model", type=str, help="resnet50 onnx file")
+    parser.add_argument("input_pb", type=str, help="input data protobuff")
+    parser.add_argument("--out_name",
+                        type=str,
+                        default="output",
+                        help="output filename")
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    ort_sess = ort.InferenceSession(args.model,
+                                    providers=['CPUExecutionProvider'])
+    input_tensor = read_pb_file(args.input_pb)
+    output_tensor = ort_sess.run(None, {"data": input_tensor})
+    output = output_tensor[0]
+    print("Output tensor shape")
+    print(output.shape)
+    write_pb_file(output, args.out_name)
+
+
+if __name__ == "__main__":
+    main()