def _load_protobuf_data(self, model_dir, data_sets: List[OnnxTestData]):
for test_data_dir in glob.glob(
os.path.join(model_dir, "test_data_set*")):
inputs = {}
outputs = {}
inputs_num = len(
glob.glob(os.path.join(test_data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir,
'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs[tensor.name] = numpy_helper.to_array(tensor)
ref_outputs_num = len(
glob.glob(os.path.join(test_data_dir, 'output_*.pb')))
for i in range(ref_outputs_num):
output_file = os.path.join(test_data_dir,
'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
outputs[tensor.name] = numpy_helper.to_array(tensor)
data_sets.append(OnnxTestData(inputs, outputs))
def load_node_tests(data_dir=os.path.join(DATA_DIR, 'node')):
'''Load node test cases from on-disk data files.
'''
testcases = []
for test_name in os.listdir(data_dir):
case_dir = os.path.join(data_dir, test_name)
# skip the non-dir files, such as generated __init__.py.
if not os.path.isdir(case_dir):
continue
node = onnx.NodeProto()
with open(os.path.join(case_dir, 'node.pb'), 'rb') as f:
node.ParseFromString(f.read())
inputs = []
inputs_num = len(glob.glob(os.path.join(case_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(case_dir, 'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs.append(tensor)
outputs = []
outputs_num = len(glob.glob(os.path.join(case_dir, 'output_*.pb')))
for i in range(outputs_num):
output_file = os.path.join(case_dir, 'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
outputs.append(tensor)
testcases.append(NodeTestCase(node, inputs, outputs, test_name))
return testcases
def _execute_pb_data(
cls,
model_dir: str,
prepared_model: BackendRep,
result_rtol: float,
result_atol: float,
) -> int:
executed_tests = 0
for test_data_dir in model_dir.glob("test_data_set*"):
inputs = []
inputs_num = len(list(test_data_dir.glob("input_*.pb")))
for i in range(inputs_num):
input_file = Path(test_data_dir) / "input_{}.pb".format(i)
tensor = onnx.TensorProto()
with open(input_file, "rb") as f:
tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(tensor))
ref_outputs = []
ref_outputs_num = len(list(test_data_dir.glob("output_*.pb")))
for i in range(ref_outputs_num):
output_file = Path(test_data_dir) / "output_{}.pb".format(i)
tensor = onnx.TensorProto()
with open(output_file, "rb") as f:
tensor.ParseFromString(f.read())
ref_outputs.append(numpy_helper.to_array(tensor))
if (len(inputs) == 0):
continue
outputs = list(prepared_model.run(inputs))
cls.assert_similar_outputs(ref_outputs, outputs, result_rtol,
result_atol)
executed_tests = executed_tests + 1
return executed_tests
def run_model(tf_rep,
test_data_dir='onnx_models/mobilenetv2-1.0/test_data_set_0'):
# Load inputs
inputs = []
inputs_num = len(glob.glob(os.path.join(test_data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir, 'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(tensor))
# Load reference outputs
ref_outputs = []
ref_outputs_num = len(glob.glob(os.path.join(test_data_dir,
'output_*.pb')))
for i in range(ref_outputs_num):
output_file = os.path.join(test_data_dir, 'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
ref_outputs.append(numpy_helper.to_array(tensor))
# Run the model on the backend
outputs = tf_rep.run(inputs)[0]
np.save('model_prediction_not_processed', outputs)
# outputs = imagenet_postprocess(outputs)
# print(outputs[:10,:])
print(outputs.shape)
# print(outputs[0,0])
print(outputs)
def load_node_tests(data_dir=os.path.join(DATA_DIR, 'node')):
testcases = []
for test_name in os.listdir(data_dir):
case_dir = os.path.join(data_dir, test_name)
node = onnx.NodeProto()
with open(os.path.join(case_dir, 'node.pb'), 'rb') as f:
node.ParseFromString(f.read())
inputs = []
inputs_num = len(glob.glob(os.path.join(case_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(case_dir, 'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs.append(tensor)
outputs = []
outputs_num = len(glob.glob(os.path.join(case_dir, 'output_*.pb')))
for i in range(outputs_num):
output_file = os.path.join(case_dir, 'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
outputs.append(tensor)
testcases.append(
NodeTestCase(node, inputs, outputs, test_name))
return testcases
def gpt2_test():
for model_class, tokenizer_class, pretrained_weights in MODELS:
# Load pretrained model/tokenizer
tokenizer = tokenizer_class.from_pretrained(pretrained_weights)
model = model_class.from_pretrained(pretrained_weights)
model.eval()
# Encode text
# Add special tokens takes care of adding [CLS], [SEP], <s>... tokens in the right way for each model.
input_ids_1 = torch.tensor([[
tokenizer.encode("Here is some text to encode Hello World",
add_special_tokens=True)
]])
with torch.no_grad():
output_1 = model(input_ids_1) # Models outputs are now tuples
model_dir, data_dir = save_model('gpt2',
model.cpu(),
input_ids_1,
output_1,
opset_version=10,
input_names=['input1'],
dynamic_axes={'input1': [0, 1, 2, 3]})
# Test exported model with TensorProto data saved in files
inputs_flatten = flatten(input_ids_1)
inputs_flatten = update_flatten_list(inputs_flatten, [])
outputs_flatten = flatten(output_1)
outputs_flatten = update_flatten_list(outputs_flatten, [])
inputs = []
for i, _ in enumerate(inputs_flatten):
f_ = os.path.join(data_dir, '{0}_{1}.pb'.format("input", i))
tensor = onnx.TensorProto()
with open(f_, 'rb') as file:
tensor.ParseFromString(file.read())
inputs.append(numpy_helper.to_array(tensor))
outputs = []
for i, _ in enumerate(outputs_flatten):
f_ = os.path.join(data_dir, '{0}_{1}.pb'.format("output", i))
tensor = onnx.TensorProto()
with open(f_, 'rb') as file:
tensor.ParseFromString(file.read())
outputs.append(numpy_helper.to_array(tensor))
inference(model_dir, inputs, outputs)
# Test exported model with a new input
print("== Feeding model with new input ==")
input_ids_2 = torch.tensor([[
tokenizer.encode(
"Here is some alternative text to encode I love Seattle",
add_special_tokens=True)
]])
with torch.no_grad():
output_2 = model(input_ids_2)
inference(model_dir, input_ids_2, output_2)
def run(test_self, device): # type: (Any, Text) -> None
if model_test.model_dir is None:
model_dir = Runner._prepare_model_data(model_test)
else:
model_dir = model_test.model_dir
model_pb_path = os.path.join(model_dir, 'model.onnx')
model = onnx.load(model_pb_path)
model_marker[0] = model
if hasattr(self.backend, 'is_compatible') \
and callable(self.backend.is_compatible) \
and not self.backend.is_compatible(model):
raise unittest.SkipTest('Not compatible with backend')
prepared_model = self.backend.prepare(model, device)
assert prepared_model is not None
# TODO after converting all npz files to protobuf, we can delete this.
for test_data_npz in glob.glob(
os.path.join(model_dir, 'test_data_*.npz')):
test_data = np.load(test_data_npz, encoding='bytes')
inputs = list(test_data['inputs'])
outputs = list(prepared_model.run(inputs))
ref_outputs = test_data['outputs']
self._assert_similar_outputs(ref_outputs,
outputs,
rtol=model_test.rtol,
atol=model_test.atol)
for test_data_dir in glob.glob(
os.path.join(model_dir, "test_data_set*")):
inputs = []
inputs_num = len(
glob.glob(os.path.join(test_data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir,
'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(tensor))
ref_outputs = []
ref_outputs_num = len(
glob.glob(os.path.join(test_data_dir, 'output_*.pb')))
for i in range(ref_outputs_num):
output_file = os.path.join(test_data_dir,
'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
ref_outputs.append(numpy_helper.to_array(tensor))
outputs = list(prepared_model.run(inputs))
self._assert_similar_outputs(ref_outputs,
outputs,
rtol=model_test.rtol,
atol=model_test.atol)
def main():
warnings.filterwarnings('ignore')
parser = argparse.ArgumentParser(description="Tool to compare output of onnx model to \
sample data obtained from the onnx model-zoo.")
parser.add_argument(
"--input",
type=Text,
required=True,
help="Path to onnx model."
)
args = parser.parse_args()
input_path = args.input
test_data_dir = os.path.join(os.path.dirname(os.path.abspath(input_path)), "test_data_set_0")
print(input_path)
print(test_data_dir)
model = onnx.load(input_path)
# Load inputs
inputs = []
inputs_num = len(glob.glob(os.path.join(test_data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir, 'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(tensor))
# Load reference outputs
ref_outputs = []
ref_outputs_num = len(glob.glob(os.path.join(test_data_dir, 'output_*.pb')))
for i in range(ref_outputs_num):
output_file = os.path.join(test_data_dir, 'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
ref_outputs.append(numpy_helper.to_array(tensor))
# Run the model on the backend
outputs = list(backend.run_model(model, inputs, device='CPU'))
# Compare the results with reference outputs.
for ref_o, o in zip(ref_outputs, outputs):
np.testing.assert_almost_equal(ref_o, o, decimal=4)
print("Reference output matches computed output of network.")
def shufflenetv2_test():
for github_repo, model in MODELS:
# Load pretrained model
model = torch.hub.load(github_repo, model, pretrained=True)
model.eval()
input_image = Image.open(filename)
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
input_tensor = preprocess(input_image)
input_1 = input_tensor.unsqueeze(0)
output_1 = model(input_1)
model_dir, data_dir = save_model('shufflenetv2',
model.cpu(),
input_1,
output_1,
opset_version=10,
input_names=['input'],
output_names=['output'])
# Test exported model with TensorProto data saved in files
inputs_flatten = flatten(input_1)
inputs_flatten = update_flatten_list(inputs_flatten, [])
outputs_flatten = flatten(output_1)
outputs_flatten = update_flatten_list(outputs_flatten, [])
inputs = []
for i, _ in enumerate(inputs_flatten):
f_ = os.path.join(data_dir, '{0}_{1}.pb'.format("input", i))
tensor = onnx.TensorProto()
with open(f_, 'rb') as file:
tensor.ParseFromString(file.read())
inputs.append(numpy_helper.to_array(tensor))
outputs = []
for i, _ in enumerate(outputs_flatten):
f_ = os.path.join(data_dir, '{0}_{1}.pb'.format("output", i))
tensor = onnx.TensorProto()
with open(f_, 'rb') as file:
tensor.ParseFromString(file.read())
outputs.append(numpy_helper.to_array(tensor))
inference(model_dir, inputs, outputs)
def load_pb_file(data_file_name, size_limit, samples, channels, height, width):
'''
Load tensor data from pb files.
:param data_file_name: path to the pb file
:param dataset_size: number of image-data in the pb file. Default is 0 which means all samples from .pb file.
:param samples: number of samples 'N'
:param channels: number of channels in the image 'C'
:param height: image height for data size check 'H'
:param width: image width for data size check 'W'
:return input data for the model
'''
tensor = onnx.TensorProto()
inputs = np.empty(0)
with open(data_file_name, 'rb') as fin:
tensor.ParseFromString(fin.read())
inputs = numpy_helper.to_array(tensor)
try:
shape = inputs.shape
dataset_size = 1
if len(shape) == 5 and (shape[0] <= size_limit or size_limit == 0):
dataset_size = shape[0]
elif len(shape) == 5 and shape[0] > size_limit:
inputs = inputs[:size_limit]
dataset_size = size_limit
inputs = inputs.reshape(dataset_size, samples, channels, height,
width)
except:
sys.exit(
"Input .pb file contains incorrect input size. \nThe required size is: (%s). The real size is: (%s)"
% ((dataset_size, samples, channels, height, width), shape))
return inputs
def _to_array(f, name=None):
assert os.path.isfile(f)
onnx_tensor = onnx.TensorProto()
with open(f, 'rb') as fp:
onnx_tensor.ParseFromString(fp.read())
if name is not None:
assert onnx_tensor.name == name
return onnx.numpy_helper.to_array(onnx_tensor)
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 tensor.name, np_array
def loadTensor(fileName):
if fileName.endswith("npz"):
return np.load(fileName, encoding="bytes")["arr_0"]
#return list(np.load(fileName, encoding="bytes")["inputs"])
tensor = onnx.TensorProto()
with open(fileName, "rb") as binaryFile:
tensor.ParseFromString(binaryFile.read())
return numpy_helper.to_array(tensor)
def _make_onnx_node_for_constant(name: str, value: int) -> Any:
tensor_value = onnx.TensorProto(
data_type=onnx.TensorProto.INT32,
name=name,
int32_data=[value],
dims=[1, 1, 1, 1],
)
return tensor_value
def tensor2dict(full_path):
t = onnx.TensorProto()
with open(full_path, 'rb') as f:
t.ParseFromString(f.read())
jsonStr = MessageToJson(t, use_integers_for_enums=True)
data = json.loads(jsonStr)
return data
def run(test_self, device):
if model_test.model_dir is None:
model_dir = self._prepare_model_data(model_test)
else:
model_dir = model_test.model_dir
model_pb_path = os.path.join(model_dir, 'model.onnx')
model = onnx.load(model_pb_path)
model_marker[0] = model
prepared_model = self.backend.prepare(model, device)
# TODO after converting all npz files to protobuf, we can delete this.
for test_data_npz in glob.glob(
os.path.join(model_dir, 'test_data_*.npz')):
test_data = np.load(test_data_npz, encoding='bytes')
inputs = list(test_data['inputs'])
outputs = list(prepared_model.run(inputs))
ref_outputs = test_data['outputs']
self._assert_similar_outputs(ref_outputs, outputs)
for test_data_dir in glob.glob(
os.path.join(model_dir, "test_data_set*")):
inputs = []
inputs_num = len(
glob.glob(os.path.join(test_data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir,
'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(tensor))
ref_outputs = []
ref_outputs_num = len(
glob.glob(os.path.join(test_data_dir, 'output_*.pb')))
for i in range(ref_outputs_num):
output_file = os.path.join(test_data_dir,
'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
ref_outputs.append(numpy_helper.to_array(tensor))
outputs = list(prepared_model.run(inputs))
self._assert_similar_outputs(ref_outputs, outputs)
def SaveTensorProto(file_path, variable, data):
tp = onnx.TensorProto()
tp.name = variable.uid
for i in range(len(variable.dynamic_axes)):
tp.dims.append(1) # pad 1 for the each dynamic axis
for d in variable.shape:
tp.dims.append(d)
tp.data_type = onnx.TensorProto.FLOAT
tp.raw_data = data.tobytes()
with open(file_path, 'wb') as f:
f.write(tp.SerializeToString())
def load_inputs(test_data_dir):
# Load inputs
inputs = []
inputs_num = len(glob.glob(os.path.join(test_data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir, 'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(tensor))
return inputs
def _get_inputs_outputs_pb(tf_rep, data_dir):
"""Get the input and reference output tensors"""
inputs = {}
inputs_num = len(glob.glob(os.path.join(data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(data_dir, 'input_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
tensor.name = tensor.name if tensor.name else tf_rep.inputs[i]
inputs[tensor.name] = onnx.numpy_helper.to_array(tensor)
ref_outputs = {}
ref_outputs_num = len(glob.glob(os.path.join(data_dir, 'output_*.pb')))
for i in range(ref_outputs_num):
output_file = os.path.join(data_dir, 'output_{}.pb'.format(i))
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
tensor.name = tensor.name if tensor.name else tf_rep.outputs[i]
ref_outputs[tensor.name] = onnx.numpy_helper.to_array(tensor)
return inputs, ref_outputs
def _load_proto(self, proto_filename, target_list, model_type_proto): # type: (Text, List[Union[np.ndarray[Any], List[Any]]], TypeProto) -> None
with open(proto_filename, 'rb') as f:
protobuf_content = f.read()
if model_type_proto.HasField('sequence_type'):
sequence = onnx.SequenceProto()
sequence.ParseFromString(protobuf_content)
target_list.append(numpy_helper.to_list(sequence))
elif model_type_proto.HasField('tensor_type'):
tensor = onnx.TensorProto()
tensor.ParseFromString(protobuf_content)
target_list.append(numpy_helper.to_array(tensor))
else:
print('Loading proto of that specific type (Map/Sparse Tensor) is currently not supported')
def load_dataset(test_data_dir):
# load inputs
inputs = []
inputs_num = len(glob.glob(os.path.join(test_data_dir, 'input_*.pb')))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir, 'input_{}.pb'.format(i))
onnx_tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
onnx_tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(onnx_tensor))
# load reference outputs
ref_outputs = []
ref_outputs_num = len(glob.glob(os.path.join(test_data_dir,
'output_*.pb')))
for i in range(ref_outputs_num):
output_file = os.path.join(test_data_dir, 'output_{}.pb'.format(i))
onnx_tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
onnx_tensor.ParseFromString(f.read())
ref_outputs.append(numpy_helper.to_array(onnx_tensor))
return inputs, ref_outputs
def _execute_pb_data(
cls, model_dir: str, prepared_model: BackendRep, result_rtol: float, result_atol: float,
) -> None:
for test_data_dir in glob.glob(os.path.join(model_dir, "test_data_set*")):
inputs = []
inputs_num = len(glob.glob(os.path.join(test_data_dir, "input_*.pb")))
for i in range(inputs_num):
input_file = os.path.join(test_data_dir, "input_{}.pb".format(i))
tensor = onnx.TensorProto()
with open(input_file, "rb") as f:
tensor.ParseFromString(f.read())
inputs.append(numpy_helper.to_array(tensor))
ref_outputs = []
ref_outputs_num = len(glob.glob(os.path.join(test_data_dir, "output_*.pb")))
for i in range(ref_outputs_num):
output_file = os.path.join(test_data_dir, "output_{}.pb".format(i))
tensor = onnx.TensorProto()
with open(output_file, "rb") as f:
tensor.ParseFromString(f.read())
ref_outputs.append(numpy_helper.to_array(tensor))
outputs = list(prepared_model.run(inputs))
cls.assert_similar_outputs(ref_outputs, outputs, result_rtol, result_atol)
def SaveTensorProto(file_path, variable, data, name):
tp = onnx.TensorProto()
tp.name = name if name else variable.uid
# ONNX input shape always has sequence axis as the first dimension, if sequence axis exists
for i in range(len(variable.dynamic_axes)):
tp.dims.append(data.shape[len(variable.dynamic_axes) - 1 - i])
for (i, d) in enumerate(variable.shape):
tp.dims.append(d) if d > 0 else tp.dims.append(
data.shape[len(data.shape) - len(variable.shape) + i])
tp.data_type = onnx.TensorProto.FLOAT
tp.raw_data = data.tobytes()
with open(file_path, 'wb') as f:
f.write(tp.SerializeToString())
def get_sample_data():
'''
Combine all input_*.pb files and output_*.pb files into a
dictionary with key being the "model.test_dir_number_x" and
the value being a list of length 2. The first value is the
input and the second value is the output.
'''
dirToInputOutput = {}
input_files = glob.glob('onnx_models/*/*/input_*.pb')
for input_file in input_files:
tensor = onnx.TensorProto()
with open(input_file, 'rb') as f:
tensor.ParseFromString(f.read())
parsed = numpy_helper.to_array(tensor)
split_result = input_file.split('/')
key = split_result[1] + '.' + split_result[2]
dirToInputOutput[key] = [parsed]
output_files = glob.glob('onnx_models/*/*/output_*.pb')
for output_file in output_files:
tensor = onnx.TensorProto()
with open(output_file, 'rb') as f:
tensor.ParseFromString(f.read())
parsed = numpy_helper.to_array(tensor)
split_result = output_file.split('/')
key = split_result[1] + '.' + split_result[2]
if not key in dirToInputOutput.keys():
print("ERROR: %v not in dictionary", output_file)
break
dirToInputOutput[key].append(parsed)
return dirToInputOutput
def test_mnist_onnx_download_extract_run():
dl_ret = wget.download(mnist_onnx_url_base + "/" + mnist_onnx_filename, out="/tmp")
shutil.unpack_archive(dl_ret, mnist_onnx_local_dir)
with open(mnist_onnx_local_dir + "/mnist/model.onnx", "rb") as f:
assert hashlib.md5(f.read()).hexdigest() == "d7cd24a0a76cd492f31065301d468c3d"
# load the onnx model
model = onnx.load(mnist_onnx_local_dir + "/mnist/model.onnx")
# load one of the test vectors
input_tensor = onnx.TensorProto()
output_tensor = onnx.TensorProto()
with open(mnist_onnx_local_dir + "/mnist/test_data_set_0/input_0.pb", "rb") as f:
input_tensor.ParseFromString(f.read())
with open(mnist_onnx_local_dir + "/mnist/test_data_set_0/output_0.pb", "rb") as f:
output_tensor.ParseFromString(f.read())
# run using FINN-based execution
input_dict = {"Input3": np_helper.to_array(input_tensor)}
output_dict = oxe.execute_onnx(model, input_dict)
assert np.isclose(
np_helper.to_array(output_tensor), output_dict["Plus214_Output_0"]
).all()
# remove the downloaded model and extracted files
os.remove(dl_ret)
shutil.rmtree(mnist_onnx_local_dir)
def read_output_from_refs(model, data_folder):
print("Reading reference outputs from {} ...".format(data_folder))
reference_output = []
for i, _ in enumerate(model.graph.output):
output_file = data_folder + '/output_{}.pb'.format(i)
output_ts = onnx.TensorProto()
with open(output_file, 'rb') as f:
output_ts.ParseFromString(f.read())
output_np = numpy_helper.to_array(output_ts)
print(" - {} output: [{}x{}]".format(
ordinal(i + 1), 'x'.join([str(i) for i in output_np.shape]),
output_np.dtype))
reference_output += [output_np]
print(" done.\n")
return reference_output
def _load(folder, names):
res = []
for name in names:
full = os.path.join(folder, name)
new_tensor = onnx.TensorProto()
with open(full, 'rb') as f:
new_tensor.ParseFromString(f.read())
try:
t = to_array(new_tensor)
except (ValueError, TypeError) as e:
raise RuntimeError(
"Unexpected format for %r. This may be not a tensor."
"" % full) from e
res.append(t)
return res
def test_export_testcase_strip_large_tensor_data():
if torch_version < version.Version('1.6.0'):
pytest.skip('skip for PyTorch 1.5 or earlier')
model = Net().to('cpu')
x = torch.zeros((1, 1, 28, 28))
output_dir = _helper(
model, x, 'mnist_stripped_tensor_data',
output_grad=True, strip_large_tensor_data=True)
assert os.path.isdir(output_dir)
assert os.path.isfile(os.path.join(output_dir, 'meta.json'))
assert os.path.isfile(os.path.join(output_dir, 'model.onnx'))
test_data_set_dir = os.path.join(output_dir, 'test_data_set_0')
assert os.path.isfile(os.path.join(test_data_set_dir, 'input_0.pb'))
assert os.path.isfile(os.path.join(test_data_set_dir, 'output_0.pb'))
for i in range(8):
assert os.path.isfile(os.path.join(
test_data_set_dir, 'gradient_{}.pb'.format(i)))
assert not os.path.isfile(os.path.join(test_data_set_dir, 'gradient_8.pb'))
with open(os.path.join(output_dir, 'meta.json')) as metaf:
metaj = json.load(metaf)
assert metaj['strip_large_tensor_data']
def check_tensor(tensor):
if is_large_tensor(tensor, LARGE_TENSOR_DATA_THRESHOLD):
assert tensor.data_location == onnx.TensorProto.EXTERNAL
assert tensor.external_data[0].key == 'location'
meta = json.loads(tensor.external_data[0].value)
assert meta['type'] == 'stripped'
assert type(meta['average']) == float
assert type(meta['variance']) == float
else:
assert len(tensor.external_data) == 0
onnx_model = onnx.load(os.path.join(
output_dir, 'model.onnx'), load_external_data=False)
for init in onnx_model.graph.initializer:
check_tensor(init)
for pb_filepath in ('input_0.pb', 'output_0.pb'):
with open(os.path.join(test_data_set_dir, pb_filepath), 'rb') as f:
tensor = onnx.TensorProto()
tensor.ParseFromString(f.read())
check_tensor(tensor)
def load_test_data(data_dir, input_names, output_names):
inout_values = []
for kind, names in [('input', input_names), ('output', output_names)]:
names = list(names)
values = []
for pb in sorted(glob.glob(os.path.join(data_dir, '%s_*.pb' % kind))):
with open(pb, 'rb') as f:
tensor = onnx.TensorProto()
tensor.ParseFromString(f.read())
if tensor.name in names:
name = tensor.name
names.remove(name)
else:
name = names.pop(0)
values.append((name, onnx.numpy_helper.to_array(tensor)))
inout_values.append(values)
return tuple(inout_values)
def load_pb_and_run(model_path, data_path, model_name, show_netron=False):
print('{}...'.format(model_name))
onnx_model = onnx.load_model(model_path)
opset = onnx_model.opset_import[0].version
print('Opset from:', opset)
if show_netron:
netron.start(model_path)
new_tensor = onnx.TensorProto() # 先建立一個空的 TensorProto 物件
with open(data_path, 'rb') as f:
new_tensor.ParseFromString(f.read())
before_opset = onnx_model.opset_import[0].version
params_name = [param.name for param in onnx_model.graph.initializer]
shape_dict = {}
data = numpy_helper.to_array(new_tensor)
for input_tensor in onnx_model.graph.input:
if input_tensor.name not in params_name:
input_name = input_tensor.name
input_shape = []
for i, dim in enumerate(input_tensor.type.tensor_type.shape.dim):
input_shape.append(dim.dim_value if isinstance(
dim.dim_value, int) else data.shape[i])
shape_dict[input_name] = input_shape
data = data.reshape(input_shape)
inputs = {input_name: data}
output_shape = [
dim.dim_value
for dim in onnx_model.graph.output[0].type.tensor_type.shape.dim
]
mod, params = relay.frontend.from_onnx(onnx_model, shape=shape_dict)
#print(before)
rt_mod = get_rt_mod(inputs, mod, params)
before_output = rt_mod.get_output(0, tvm.nd.empty(output_shape,
'float32')).asnumpy()
onnx_model = relay.frontend.to_onnx(mod, params, model_name, opset=opset)
onnx.save(onnx_model, 'model.onnx')
if show_netron:
netron.start('model.onnx', port=3030)
onnx_model = onnx.load('model.onnx')
after_opset = onnx_model.opset_import[0].version
print(after_opset)
mod, params = relay.frontend.from_onnx(onnx_model, shape=shape_dict)
rt_mod = get_rt_mod(inputs, mod, params)
after_output = rt_mod.get_output(0, tvm.nd.empty(output_shape,
'float32')).asnumpy()
assert np.array_equal(before_output,
after_output), 'The outputs of are different!'
