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!'