def estimate_grads(specLB, specUB, dim_samples=3): specLB = np.array(specLB, dtype=np.float32) specUB = np.array(specUB, dtype=np.float32) inputs = [((dim_samples - i) * specLB + i * specUB) / dim_samples for i in range(dim_samples + 1)] diffs = np.zeros(len(specLB)) # refactor this out of this method if is_onnx: runnable = rt.prepare(model, 'CPU') elif sess is None: runnable = tf.Session() else: runnable = sess for sample in range(dim_samples + 1): pred = model_predict(runnable, inputs[sample]) for index in range(len(specLB)): if sample < dim_samples: l_input = [m if i != index else u for i, m, u in zip(range(len(specLB)), inputs[sample], inputs[sample+1])] l_input = np.array(l_input, dtype=np.float32) l_i_pred = model_predict(runnable, l_input) else: l_i_pred = pred if sample > 0: u_input = [m if i != index else l for i, m, l in zip(range(len(specLB)), inputs[sample], inputs[sample-1])] u_input = np.array(u_input, dtype=np.float32) u_i_pred = model_predict(runnable, u_input) else: u_i_pred = pred diff = np.sum([abs(li - m) + abs(ui - m) for li, m, ui in zip(l_i_pred, pred, u_i_pred)]) diffs[index] += diff return diffs / dim_samples
def test_knn(iris_df): folder = os.environ.get("ONNXTESTDUMP", "tests_dump") basename = "SklearnKNeighborsClassifierMulti" os.makedirs(folder, exist_ok=True) x_columns = [ 'sepal length (cm)', 'sepal width (cm)', 'petal length (cm)' ] y_columns = ['plant_type'] x_nda = iris_df[x_columns].values.astype(np.float32) y_1da = iris_df[y_columns].values.astype("<U10") model = KNeighborsClassifier() model.fit(x_nda, y_1da) prediction = [model.predict(x_nda), model.predict_proba(x_nda)] model_onnx = convert_sklearn( model=model, name="KNN classifier multi-class", initial_types=[("input", FloatTensorType([None, x_nda.shape[1]]))], # target_opset=TARGET_OPSET ) dest_data = os.path.join(folder, f"{basename}.data.pkl") with open(dest_data, "wb") as data_file: pickle.dump(x_nda, data_file) dest_expected = os.path.join(folder, f"{basename}.expected.pkl") with open(dest_expected, "wb") as expected_file: pickle.dump(prediction, expected_file) dest_pkl = os.path.join(folder, f"{basename}.model.pkl") with open(dest_pkl, "wb") as pickle_file: pickle.dump(model, pickle_file) dest_onnx = os.path.join(folder, f"{basename}.model.onnx") with open(dest_onnx, "wb") as onnx_file: logging.info(f"created {onnx_file}") onnx_file.write(model_onnx.SerializeToString()) onnx_graph = onnx.load(dest_onnx) print("doc_string={}".format(onnx_graph.doc_string)) print("domain={}".format(onnx_graph.domain)) print("ir_version={}".format(onnx_graph.ir_version)) print("metadata_props={}".format(onnx_graph.metadata_props)) print("model_version={}".format(onnx_graph.model_version)) print("producer_name={}".format(onnx_graph.producer_name)) print("producer_version={}".format(onnx_graph.producer_version)) rep = backend.prepare(onnx_graph, 'CPU') prediction_from_saved = rep.run(x_nda) prediction_from_saved_df = pd.DataFrame(prediction_from_saved[1]) prediction_from_saved_df.columns = prediction_from_saved_df.columns.map("plant_type_is_{}".format) prediction_from_saved_df['plant_type_pred'] = pd.Series(prediction_from_saved[0]) assert prediction_from_saved_df.shape == (x_nda.shape[0], 4)
def testRunModel(self): name = get_name("mul_1.onnx") rep = backend.prepare(name) x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32) res = rep.run(x) output_expected = np.array([[1.0, 4.0], [9.0, 16.0], [25.0, 36.0]], dtype=np.float32) np.testing.assert_allclose(output_expected, res[0], rtol=1e-05, atol=1e-08)
def test_abc(): base_path = Path(__file__).parent filename = "examples/ONNX/abc_basic-mdf.json" file_path = (base_path / "../../.." / filename).resolve() # Load the MDF model mdf_model = load_mdf(str(file_path)) # Test input test_input = np.array([[0, 0, 0], [1, 1, 1]], dtype=np.float32) # Get the result of MDF execution mdf_executable = EvaluableGraph(mdf_model.graphs[0], verbose=False) mdf_executable.evaluate(initializer={"input": test_input}) mdf_output = mdf_executable.enodes["Cos_2"].evaluable_outputs[ "_3"].curr_value # Get the translated ONNX model onnx_models = mdf_to_onnx(mdf_model) # Bluffing onnx that our model is 13 when it is actually 15. This is needed for older onnxruntime # installations to run this model. See https://github.com/onnx/onnx/issues/3205 onnx_models[0].opset_import[0].version = 13 # Get the result of running the ONNX model session = backend.prepare(onnx_models[0]) onnx_output = session.run( test_input) # run returns a list with the actual result and type onnx_res_output = np.array(onnx_output[0]) assert np.array_equal(onnx_res_output, mdf_output)
def test_ab(): base_path = Path(__file__).parent filename = "examples/ONNX/ab.json" file_path = (base_path / "../../.." / filename).resolve() # Load the MDF model mdf_model = load_mdf(str(file_path)) # Test input test_input = np.array([[0, 0, 0], [1, 1, 1]], dtype=np.float32) # Get the result of MDF execution mdf_executable = EvaluableGraph(mdf_model.graphs[0], verbose=False) # TODO: the int type cast is necessaryf or now because the nodes' parameters are constants and inputs must have # the same type mdf_executable.evaluate(initializer={"input": test_input.astype(int)}) mdf_output = mdf_executable.enodes["Mul_3"].evaluable_outputs[ "_4"].curr_value # Get the translated ONNX model onnx_models = mdf_to_onnx(mdf_model) # Bluffing onnx that our model is 13 when it is actually 15. This is needed for older onnxruntime # installations to run this model. See https://github.com/onnx/onnx/issues/3205 onnx_models[0].opset_import[0].version = 13 # Get the result of running the ONNX model session = backend.prepare(onnx_models[0]) onnx_output = session.run( test_input) # run returns a list with the actual result and type onnx_res_output = np.array(onnx_output[0]) # print(f"Output calculated by onnxruntime: {onnx_res_output} and MDF: {mdf_output.astype(float)}") assert np.array_equal(onnx_res_output, mdf_output)
def testRunModelNonTensor(self): name = self.get_name("pipeline_vectorize.onnx") rep = backend.prepare(name) x = {0: 25.0, 1: 5.13, 2: 0.0, 3: 0.453, 4: 5.966} res = rep.run(x) output_expected = np.array([[49.752754]], dtype=np.float32) np.testing.assert_allclose(output_expected, res[0], rtol=1e-05, atol=1e-08)
def testRunModelProto(self): name = datasets.get_example("logreg_iris.onnx") model = load(name) rep = backend.prepare(model) x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32) res = rep.run(x) output_expected = np.array([0, 0, 0], dtype=np.float32) np.testing.assert_allclose(output_expected, res[0], rtol=1e-05, atol=1e-08) output_expected = [{ 0: 0.950599730014801, 1: 0.027834169566631317, 2: 0.02156602405011654 }, { 0: 0.9974970817565918, 1: 5.6299926654901356e-05, 2: 0.0024466661270707846 }, { 0: 0.9997311234474182, 1: 1.1918064757310276e-07, 2: 0.00026869276189245284 }] check_list_of_map_to_float(self, output_expected, res[1])
def _create_session_via_backend_api(self, model): self.device = re.match( DEVICE_REGEX, self.get_value_from_config('device').lower()).group('device') beckend_rep = backend.prepare(model=str(model), device=self.device.upper()) return beckend_rep._session # pylint: disable=W0212
def _create_session_via_backend_api(self, model): device = self.get_value_from_config('device') or 'cpu' device_match = re.match(DEVICE_REGEX, device.lower()) if not device_match: raise ConfigError('unknown device: {}'.format(device)) self.device = device_match.group('device') beckend_rep = backend.prepare(model=str(model), device=self.device.upper()) return beckend_rep._session # pylint: disable=W0212
def run_convlution_op(x, w, conv_attribute, output_shape): print(conv_attribute) # Create inputs (ValueInfoProto) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, list(x.shape)) input_w = helper.make_tensor_value_info('conv_w', TensorProto.FLOAT, list(w.shape)) # Create output (ValueInfoProto) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, output_shape) # Create initializer conv_weight = w.flatten() conv_weight = list(conv_weight) conv_w = helper.make_tensor(name="conv_w", data_type=TensorProto.FLOAT, dims=list(w.shape), vals=conv_weight, raw=False) # create node node = onnx.helper.make_node(op_type='Conv', inputs=['X', 'conv_w'], outputs=['Y'], kernel_shape=conv_attribute["kernel_shape"], pads=conv_attribute["pads"], strides=conv_attribute["strides"], group=conv_attribute['group'], dilations=conv_attribute['dilations']) # create graph graph_def = helper.make_graph(nodes=[node], name='test-model', inputs=[X, input_w], outputs=[Y], initializer=[conv_w]) # create model model_def = helper.make_model(graph_def, producer_name='sun') onnx.checker.check_model(model_def) # model = onnx.load(onnx_file) session = backend.prepare(model_def) output = session.run(x) output = np.array(output[0]) print(output) print(output.shape) #save onnx model onnx.save(model_def, 'convlution.onnx') print("save file convlution.onnx") output = np.array(output) np.save('convlution', output) print("save output convlution.npy") return output
def get_feature(onnx_file, aligned, batching=False): if not batching: # ONE INPUT input_blob = np.expand_dims(aligned, axis=0).astype(np.float32) #NCHW # ONE INPUT else: # BATCHING input_blob = np.expand_dims(aligned, axis=0).astype(np.float32) #NCHW input_blob = np.squeeze(input_blob) # BATCHING onnx_model = onnx.load(onnx_file) ort_session = backend.prepare(onnx_model, 'GPU') outputs = ort_session.run(input_blob) return outputs
def run_model(data: bytearray, model: ModelProto): """Run model and check result""" x = np.array(data, dtype=np.int64) i = np.array([0], dtype=np.int64) keep_going = np.array([True], dtype=np.bool) max_index = np.array([32], dtype=np.int64) model_rep = prepare(model) out = model_rep.run([x, i, keep_going, max_index])[1].reshape((1, 30))[0] assert np.array_equal( out, np.array( [ 16780, 9831, 2538, 14031, 8110, 19136, 17547, 13929, 16911, 20265, 15014, 24203, 9238, 12759, 17883, 5871, 15265, 13222, 11014, 8290, 7843, 16989, 7222, 20835, 15431, 4554, 8498, 11543, 6214, 7169, ], dtype=np.int64, ), ) print(f"Flag: ctfzone\x7b{data.decode()}\x7d")
def run_relu_op(x): # Create inputs (ValueInfoProto) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, list(x.shape)) # Create output (ValueInfoProto) # output形状应该和input相同, output_shape = list(x.shape) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, output_shape) # create node node = onnx.helper.make_node( op_type='Relu', inputs=['X'], outputs=['Y'], ) # create graph graph_def = helper.make_graph( nodes=[node], name='test-model', inputs=[X], outputs=[Y], ) # create model model_def = helper.make_model(graph_def, producer_name='sun') onnx.checker.check_model(model_def) # model = onnx.load(onnx_file) session = backend.prepare(model_def) output = session.run(x) output = np.array(output[0]) print(output) print(output.shape) #save onnx model onnx.save(model_def, 'relu.onnx') print("save file relu.onnx") output = np.array(output) np.save('relu', output) print("save output relu.npy") return output
def get_feature(aligned, batching=False): if not batching: # ONE INPUT input_blob = np.expand_dims(aligned, axis=0).astype(np.float32) #NCHW # ONE INPUT else: # BATCHING input_blob = np.expand_dims(aligned, axis=0).astype(np.float32) #NCHW input_blob = np.squeeze(input_blob) # BATCHING onnx_model = onnx.load(onnx_file) ''' You can delete this one if not works ''' # iterate through inputs of the graph # for input in onnx_model.graph.input: # print (input.name, end=": ") # # get type of input tensor # tensor_type = input.type.tensor_type # # check if it has a shape: # if (tensor_type.HasField("shape")): # # iterate through dimensions of the shape: # for d in tensor_type.shape.dim: # # the dimension may have a definite (integer) value or a symbolic identifier or neither: # if (d.HasField("dim_value")): # print (d.dim_value, end=", ") # known dimension # elif (d.HasField("dim_param")): # print (d.dim_param, end=", ") # unknown dimension with symbolic name # else: # print ("?", end=", ") # unknown dimension with no name # else: # print ("unknown rank", end="") # print() ''' You can delete this one if not works ''' ort_session = backend.prepare(onnx_model, 'GPU') #ort_session.get_providers() #ort.session.set_providers(['CUDAExecutionProvider']) outputs = ort_session.run(input_blob) # cnt = 0 # print(len(outputs)) #for output in outputs: # print('Output '+str(cnt), output.shape) # cnt+=1 # print('im_scale:',scales) return outputs
def _estimate_grads(specLB, specUB, model, dim_samples=3, input_shape=(1, )): # Estimate gradients using central difference quotient and average over dim_samples+1 in the range of the input bounds # Very computationally costly specLB = np.array(specLB, dtype=np.float32) specUB = np.array(specUB, dtype=np.float32) inputs = [(((dim_samples - i) * specLB + i * specUB) / dim_samples).reshape(*input_shape) for i in range(dim_samples + 1)] diffs = np.zeros(len(specLB)) # ONNX assumed runnable = rt.prepare(model, 'CPU') for sample in range(dim_samples + 1): pred = _onnx_predict(runnable, inputs[sample]) for index in range(len(specLB)): if sample < dim_samples: l_input = [ m if i != index else u for i, m, u in zip( range(len(specLB)), inputs[sample], inputs[sample + 1]) ] l_input = np.array(l_input, dtype=np.float32) l_i_pred = _onnx_predict(runnable, l_input) else: l_i_pred = pred if sample > 0: u_input = [ m if i != index else l for i, m, l in zip( range(len(specLB)), inputs[sample], inputs[sample - 1]) ] u_input = np.array(u_input, dtype=np.float32) u_i_pred = _onnx_predict(runnable, u_input) else: u_i_pred = pred diff = np.sum([ abs(li - m) + abs(ui - m) for li, m, ui in zip(l_i_pred, pred, u_i_pred) ]) diffs[index] += diff return diffs / dim_samples
def onnx_run(OnnxName, x): model_name = OnnxName model = onnx.load(model_name) print("load onnx model : ", model_name) print("input data shepe: ", x.dtype, x.shape) print(onnx.checker.check_model(model)) # # model shape_inference # shape_model = shape_inference.infer_shapes(model) # onnx.checker.check_model(shape_model) # onnx.save(shape_model, test_dir + "simple_net_shaped.onnx") # # model optimizer # passes = None # opti_mode = onnx.optimizer.optimize(shape_model, passes) # onnx.save(shape_model, test_dir + "simple_net_opt.onnx") session = backend.prepare(model) output = session.run(x) output = np.array(output[0]) return output
def test(self): _model = onnx.load(self.model_path) print("Total node count in model: ", len(_model.graph.node)) # The input tensors could be provided as constants # The example below illustrates such a dictionary could be # provided for models with unknown input shapes. Since # mnist has known input shape, we don't provide input tensors. # input_tensors = {'Input3': tf.constant(0, dtype = tf.float32, # name='Input3', # shape=[1, 1, 28, 28])} input_tensors = {} tensor_dict = otf.prepare(_model, gen_tensor_dict=True, input_tensor_dict=input_tensors).tensor_dict more_outputs = [] output_to_check = [] for node in _model.graph.node: # add the first output of each node to the model output output_tensor = None for i in range(len(_model.graph.value_info)): if _model.graph.value_info[i].name == node.output[0]: output_tensor = _model.graph.value_info[i] for i in range(len(_model.graph.initializer)): if _model.graph.initializer[i].name == node.output[0]: output_tensor = _model.graph.initializer[i] # assume the first output is a tensor tensor = tensor_dict[node.output[0]] output_tensor = helper.make_tensor_value_info( node.output[0], data_type.tf2onnx(tensor.dtype), tensor.shape) if output_tensor is None else output_tensor more_outputs.append(output_tensor) output_to_check.append(node.output[0]) _model.graph.output.extend(more_outputs) tf_rep = otf.prepare(_model) rt_rep = ort.prepare(_model) # prepare input data mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 sample = x_test[:1].reshape(1, 1, 28, 28).astype(np.float32) inputs = [sample] my_out = tf_rep.run(inputs) rt_out = rt_rep.run(inputs) for op in output_to_check: for i in range(len(my_out)): # find the index of output in the list if my_out[op] is my_out[i]: try: np.savetxt(op.replace("/", "__") + ".rt", rt_out[i].flatten(), delimiter='\t') np.savetxt(op.replace("/", "__") + ".tf", my_out[i].flatten(), delimiter='\t') np.testing.assert_allclose(my_out[i], rt_out[i], rtol=1e-2) print( op, "results of this layer are correct within tolerence." ) except Exception as e: np.set_printoptions(threshold=np.inf) mismatch_percent = (find_between( str(e), "(mismatch", "%)")) print( op, "mismatch with percentage {} %".format( mismatch_percent))
import numpy as np from onnxruntime import datasets from onnxruntime.capi.onnxruntime_pybind11_state import InvalidArgument import onnxruntime.backend as backend from onnx import load ######################################## # The device depends on how the package was compiled, # GPU or CPU. from onnxruntime import get_device device = get_device() name = datasets.get_example("logreg_iris.onnx") model = load(name) rep = backend.prepare(model, device) x = np.array([[-1.0, -2.0]], dtype=np.float32) try: label, proba = rep.run(x) print("label={}".format(label)) print("probabilities={}".format(proba)) except (RuntimeError, InvalidArgument) as e: print(e) ######################################## # The backend can also directly load the model # without using *onnx*. rep = backend.prepare(name, device) x = np.array([[-1.0, -2.0]], dtype=np.float32) try:
def main(): global args, best_prec1 args = parser.parse_args() # step 1.1, create pretrained model to transform to onnx model print("=> creating model '{}'".format(args.arch)) if args.model == '': if args.pretrained.lower() not in ['false', 'none', 'not', 'no', '0']: print("=> using pre-trained parameters '{}'".format( args.pretrained)) Model = pretrainedmodels.__dict__[args.arch]( num_classes=1000, pretrained=args.pretrained) else: Model = pretrainedmodels.args.arch if args.model == 'mobilenet_v2' or args.model == 'mobilenetv2': Model = mobilenet_v2(pretrained=True) if args.model == 'googlenet': Model = googlenet(pretrained=True) if args.model == 'shufflenet_v2' or args.model == 'shufflenetv2': Model = shufflenet_v2_x0_5(pretrained=True) # Use this an input trace to serialize the model input_shape = (3, int(args.h), int(args.w)) if args.model == '': modelname = args.arch else: modelname = args.model model_onnx_path = "models_converted/%s-pytorch.onnx" % modelname model = Model if args.model == '': model.train(False) # step 1.2 Export the model to an ONNX file dummy_input = Variable(torch.randn(1, *input_shape)) torch.save(model, 'models_converted/%s.path' % modelname) torch_onnx.export(model, dummy_input, model_onnx_path, verbose=False) print('++++++++++++++++++++++++++++++++++++++++++++++++++++++') print("=> Export of %s-pytorch.onnx complete!" % modelname) print('++++++++++++++++++++++++++++++++++++++++++++++++++++++') if args.model != '': print('The checking processing only support the <arch> mode.') else: # step 2, create onnx_model using onnxruntime as backend. check if right and export graph. image_path = 'data/2127.jpg' # output_pytorch, img_np = modelhandle.process(image) load_img = pretrainedmodels.utils.LoadImage() # transformations depending on the model # rescale, center crop, normalize, and others (ex: ToBGR, ToRange255) tf_img = pretrainedmodels.utils.TransformImage(model) # path_img = 'data/cat.jpg' input_img = load_img(image_path) input_tensor = tf_img( input_img) # 3x400x225 -> 3x299x299 size may differ input_tensor = input_tensor.unsqueeze(0) # 3x299x299 -> 1x3x299x299 input = torch.autograd.Variable(input_tensor, requires_grad=False) # step 2.1 output the result of the test with pytorch output_pytorch = model(input) # 1x1000 # print('output_pytorch = {}'.format(output_pytorch)) # step 2.2 output the result of test with onnx img_np = input.cpu().detach().numpy() print('=> The size of input is ', img_np.shape) onnx_model = onnx.load(model_onnx_path) rep = prepare(onnx_model, strict=False) output_onnx = rep.run(img_np) output_onnx = np.mean(output_onnx, axis=1) # print(output_onnx_tf) # print('output_onnx_tf = {}'.format(output_onnx)) #step 2.3 output the different of result between two models diff = output_onnx - output_pytorch.detach().numpy() diff = np.mean(diff, axis=1) print('++++++++++++++++++++++++++++++++++++++++++++++++++++++') print("=> the precentage of different is %f " % diff[0]) if diff <= 0.01: print("=> Model Exporting is Successful") print( "=> Please check the model in direction 'models_converted/%s-pytorch.onnx'" % modelname) else: print('=> Model Exporitng may have problem, please check again') print('++++++++++++++++++++++++++++++++++++++++++++++++++++++') n = args.result if n == 'Y' or n == 'y': print('output_pytorch = {}'.format(output_pytorch)) print('output_onnx_tf = {}'.format(output_onnx))
""" import skl2onnx import onnxruntime import onnx import sklearn import numpy from onnxruntime import get_device import numpy as np from onnxruntime import datasets import onnxruntime.backend as backend from onnx import load name = datasets.get_example("logreg_iris.onnx") model = load(name) rep = backend.prepare(model, 'CPU') x = np.array( [[-1.0, -2.0, 5.0, 6.0], [-1.0, -2.0, -3.0, -4.0], [-1.0, -2.0, 7.0, 8.0]], dtype=np.float32) label, proba = rep.run(x) print("label={}".format(label)) print("probabilities={}".format(proba)) ######################################## # The device depends on how the package was compiled, # GPU or CPU. print(get_device()) ######################################## # The backend can also directly load the model # without using *onnx*.
import numpy as np import onnx import onnxruntime.backend as backend # import caffe2.python.onnx.backend as backend import os, sys if len(sys.argv) != 2: print("Usage:", sys.argv[0], " OnnxModel") sys.exit(-1) model = onnx.load(sys.argv[1]) session = backend.prepare(model, strict=False) # get input data # x = np.random.randn(1, 3, 224, 224).astype(np.float32) x = np.load("test_1_3_224_224.npy").astype(np.float32) print(x.shape) print(x) # Run the model on the backend output = session.run(x) # output = np.array(output) # print(output.shape) print(output)
def __init__(self, modelfile=onnx, device='cuda'): model = load(modelfile) self.rep = backend.prepare(model)
def run_model_test(model: ModelProto): data = bytearray(("1" * 32).encode()) x = np.array(data, dtype=np.int64) i = np.array([0], dtype=np.int64) keep_going = np.array([True], dtype=np.bool) max_index = np.array([32], dtype=np.int64) model_rep = prepare(model) standard = model_rep.run([x, i, keep_going, max_index])[1].reshape( (1, 30))[0] res = [] for c in range(0, 32): inp = "1" * c + "2" + "1" * (31 - c) data = bytearray((inp).encode()) x = np.array(data, dtype=np.int64) i = np.array([0], dtype=np.int64) keep_going = np.array([True], dtype=np.bool) max_index = np.array([32], dtype=np.int64) model_rep = prepare(model) out = model_rep.run([x, i, keep_going, max_index])[1].reshape( (1, 30))[0] buf = (out - standard) res.append(buf) print(str(c) + ": " + str(buf)) fin = [ 16780, 9831, 2538, 14031, 8110, 19136, 17547, 13929, 16911, 20265, 15014, 24203, 9238, 12759, 17883, 5871, 15265, 13222, 11014, 8290, 7843, 16989, 7222, 20835, 15431, 4554, 8498, 11543, 6214, 7169, ] X = [z3.Int('x%s' % i) for i in range(32)] s = z3.Solver() for i in range(len(res[0])): string = "" for b in range(len(res)): if (res[b][i] != 0): string += f"{res[b][i]}*X[{b}]+" string = string[:-1] + f"=={fin[i]}" s.add(eval(string)) for i in range(32): s.add(X[i] >= 32, X[i] < 126) print(s.check()) for i in range(32): print(chr(int(s.model()[X[i]].as_string())), end="") print()
dtype=np.float32).reshape([1, 28, 28, 1]) if is_onnx: input = input.transpose(0, 3, 1, 2) for name, shape in output_info: out_node = helper.ValueInfoProto(type=helper.TypeProto()) out_node.name = name out_node.type.tensor_type.elem_type = model.graph.output[ 0].type.tensor_type.elem_type if len(shape) == 4: shape = [shape[0], shape[3], shape[1], shape[2]] for dim_value in shape: dim = out_node.type.tensor_type.shape.dim.add() dim.dim_value = dim_value model.graph.output.append(out_node) runnable = rt.prepare(model, 'CPU') pred = runnable.run(input) #print(pred) else: if not (is_saved_tf_model or is_pb_file): input = np.array(test_input, dtype=np.float32) output_names = [e[0] for e in output_info] pred = sess.run( get_out_tensors(output_names), {sess.graph.get_operations()[0].name + ':0': input}) #print(pred) pred_eran = np.asarray([(i + j) / 2 for i, j in zip(nlb[-1], nub[-1])]) pred_model = np.asarray(pred[-1]).reshape(-1) if len(pred_eran) != len(pred_model): tested_file.write(', '.join([
results[file] = node print("total: ", total_num) print("top1_accuracy_rate: ", top1_num / total_num) print("top5_accuracy_rate: ", top5_num / total_num) sorted_results = sorted(results.keys()) for i in sorted_results: temp = "img[%03s] lable[%-3s] result[%-19s] top1[%s] top5[%s]"%\ (i.split('.')[0], results[i]["label"], results[i]["result"], results[i]["top1"], results[i]["top5"]) print(temp) print("test dir: ", test_dir) print("total: ", total_num) print("top1 hit: ", top1_num) print("top5 hit: ", top5_num) print("top1_accuracy_rate: ", top1_num / total_num) print("top5_accuracy_rate: ", top5_num / total_num) if __name__ == "__main__": if len(sys.argv) != 3: print("Usage:", sys.argv[0], " OnnxModel testFileDir") sys.exit(-1) file_path = sys.argv[2] model = onnx.load(sys.argv[1]) session = backend.prepare(model) onnx_ference(sys.argv[2])
def run_bn_op(x, sacle, b, mean, var, attribute): print(attribute) # Create inputs (ValueInfoProto) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, list(x.shape)) input_sacle = helper.make_tensor_value_info('scale_scale', TensorProto.FLOAT, list(sacle.shape)) input_b = helper.make_tensor_value_info('scale_b', TensorProto.FLOAT, list(b.shape)) input_mean = helper.make_tensor_value_info('bn_mean', TensorProto.FLOAT, list(mean.shape)) input_var = helper.make_tensor_value_info('bn_var', TensorProto.FLOAT, list(var.shape)) # Create output (ValueInfoProto) # output形状应该和input相同, output_shape = list(x.shape) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, output_shape) # Create initializer sacle_data = sacle.flatten() sacle_data = list(sacle_data) init_scale = helper.make_tensor( name = "scale_scale", data_type = TensorProto.FLOAT, dims = list(sacle.shape), vals = sacle_data, raw = False ) b_data = b.flatten() b_data = list(b_data) init_b = helper.make_tensor( name = "scale_b", data_type = TensorProto.FLOAT, dims = list(b.shape), vals = b_data, raw = False ) mean_data = mean.flatten() mean_data = list(mean_data) init_mean = helper.make_tensor( name = "bn_mean", data_type = TensorProto.FLOAT, dims = list(sacle.shape), vals = mean_data, raw = False ) var_data = var.flatten() var_data = list(var_data) init_var = helper.make_tensor( name = "bn_var", data_type = TensorProto.FLOAT, dims = list(var.shape), vals = var_data, raw = False ) # create node node = onnx.helper.make_node( op_type = 'BatchNormalization', inputs=['X', 'scale_scale', 'scale_b', 'bn_mean', 'bn_var'], outputs=['Y'], epsilon=attribute["epsilon"], momentum=attribute["momentum"], ) # create graph graph_def = helper.make_graph( nodes = [node], name = 'test-model', inputs = [X, input_sacle, input_b, input_mean, input_var], outputs = [Y], initializer = [init_scale, init_b, init_mean, init_var] ) # create model model_def = helper.make_model(graph_def, producer_name='sun') onnx.checker.check_model(model_def) # model = onnx.load(onnx_file) session = backend.prepare(model_def) output = session.run(x) output = np.array(output[0]) print(output) print(output.shape) #save onnx model onnx.save(model_def, 'batchNormalization.onnx') print("save file batchNormalization.onnx") output = np.array(output) np.save('batchNormalization', output) print("save output batchNormalization.npy") return output