def compare_with_pytorch(self, pytorch_model, input_shape_with_batch, compare_result=True, rtol=1e-6, atol=1e-6): input_shape_with_batch = to_list(input_shape_with_batch) onnx_path = self.dump_pytorch_to_onnx(pytorch_model, input_shape_with_batch) onnx_model = onnx.load(onnx_path) # TODO: we only consider single output for now. input_data_with_batch = [ np.random.uniform(0, 1, shape).astype(np.float32) for shape in input_shape_with_batch ] # coutput = caffe2.python.onnx.backend.run_model(onnx_model, input_data_with_batch)[0] pytorch_out = pytorch_model.forward( self._convert_ndarray_to_tensor(input_data_with_batch)) zmodel = OnnxLoader(onnx_model.graph).to_keras() zoutput = zmodel.forward(input_data_with_batch[0] if len( input_data_with_batch) == 1 else input_data_with_batch) if compare_result: self.assert_allclose(pytorch_out.detach().numpy(), zoutput, rtol, atol)
def compare_with_pytorch(self, pytorch_model, input_shape_with_batch): onnx_path = self.dump_pytorch_to_onnx(pytorch_model, input_shape_with_batch) onnx_model = onnx.load(onnx_path) # TODO: we only consider single input and output for now. input_data_with_batch = np.random.uniform(0, 1, input_shape_with_batch).astype(np.float32) # coutput = caffe2.python.onnx.backend.run_model(onnx_model, input_data_with_batch)[0] pytorch_out = pytorch_model.forward(torch.from_numpy(input_data_with_batch)) zmodel = OnnxLoader(onnx_model.graph).to_keras() zoutput = zmodel.forward(input_data_with_batch) self.assert_allclose(pytorch_out.detach().numpy(), zoutput)
def test_conv_with_padding(self): x = np.array([[[ [0., 1., 2., 3., 4.], # (1, 1, 5, 5) input tensor [5., 6., 7., 8., 9.], [10., 11., 12., 13., 14.], [15., 16., 17., 18., 19.], [20., 21., 22., 23., 24.] ]]]).astype(np.float32) W = np.array([[[ [1., 1., 1.], # (1, 1, 3, 3) tensor for convolution weights [1., 1., 1.], [1., 1., 1.] ]]]).astype(np.float32) # Convolution with padding node_with_padding = helper.make_node( 'Conv', inputs=['x', 'W'], outputs=['y'], kernel_shape=[3, 3], # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1 pads=[1, 1, 1, 1], ) y_with_padding = np.array([[[ [12., 21., 27., 33., 24.], # (1, 1, 5, 5) output tensor [33., 54., 63., 72., 51.], [63., 99., 108., 117., 81.], [93., 144., 153., 162., 111.], [72., 111., 117., 123., 84.] ]]]).astype(np.float32) output = OnnxLoader.run_node(node_with_padding, [x, W]) np.testing.assert_almost_equal(output["y"], y_with_padding, decimal=5)
def test_softmax(self): node = helper.make_node('Softmax', inputs=['x'], outputs=['y']) x = np.array([[-1, 0, 1]]).astype(np.float32) # expected output [[0.09003058, 0.24472848, 0.66524094]] y = np.exp(x) / np.sum(np.exp(x), axis=1) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_onnx_elu_default(self): node = onnx.helper.make_node('Elu', inputs=['x'], outputs=['y']) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 1.0 output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_maxpool2d_pads01(self): import pytest with pytest.raises(Exception) as e_info: node = onnx.helper.make_node('MaxPool', inputs=['x'], outputs=['y'], kernel_shape=[3, 3], pads=[0, 0, 1, 1]) x = np.random.randn(1, 3, 28, 28).astype(np.float32) x_shape = np.shape(x) kernel_shape = (3, 3) strides = (1, 1) pad_top = pad_left = 0 pad_bottom = pad_right = 1 pad_shape = [pad_top + pad_bottom, pad_left + pad_right] out_shape = pool_op_common.get_output_shape( 'VALID', np.add(x_shape[2:], pad_shape), kernel_shape, strides) padded = np.pad(x, ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), mode='constant', constant_values=np.nan) y = pool_op_common.pool(padded, x_shape, kernel_shape, strides, out_shape, pad_shape, 'MAX') output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_lrn(self): import math alpha = 0.0002 beta = 0.5 bias = 2.0 nsize = 3 node = onnx.helper.make_node('LRN', inputs=['x'], outputs=['y'], alpha=alpha, beta=beta, bias=bias, size=nsize) x = np.random.randn(5, 5, 5, 5).astype(np.float32) square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32) for n, c, h, w in np.ndindex(x.shape): square_sum[n, c, h, w] = sum( x[n, max(0, c - int(math.floor((nsize - 1) / 2)) ):min(5, c + int(math.ceil((nsize - 1) / 2)) + 1), h, w]**2) y = x / ((bias + (alpha / nsize) * square_sum)**beta) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_neg(self): node = onnx.helper.make_node( 'Neg', inputs=['x'], outputs=['y'], ) x = np.array([-4, 2]).astype(np.float32).reshape([2, 1]) y = np.negative(x) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.negative(x) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_sub(self): node = onnx.helper.make_node( 'Sub', inputs=['x', 'y'], outputs=['z'], ) x = np.array([1, 2, 3]).astype(np.float32).reshape([3, 1]) y = np.array([3, 2, 1]).astype(np.float32).reshape([3, 1]) z = x - y output = OnnxLoader.run_node(node, [x, y]) np.testing.assert_almost_equal(output["z"], z, decimal=5) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.random.randn(3, 4, 5).astype(np.float32) z = x - y output = OnnxLoader.run_node(node, [x, y]) np.testing.assert_almost_equal(output["z"], z, decimal=5)
def test_onnx_tanh(self): node = onnx.helper.make_node( 'Tanh', inputs=['x'], outputs=['y'], ) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.tanh(x) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y)
def test_onnx_log(self): node = onnx.helper.make_node( 'Log', inputs=['x'], outputs=['y'], ) x = np.exp(np.random.randn(3, 4, 5).astype(np.float32)) y = np.log(x) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_sigmoid(self): node = helper.make_node( 'Sigmoid', inputs=['x'], outputs=['y'], ) x = np.array([[-1, 0, 1]]).astype(np.float32) y = 1.0 / (1.0 + np.exp(np.negative(x))) # expected output [0.26894143, 0.5, 0.7310586] output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_relu(self): node = helper.make_node( 'Relu', inputs=['x'], outputs=['y'] ) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.clip(x, 0, np.inf) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_squeeze_none(self): node = onnx.helper.make_node( 'Squeeze', inputs=['x'], outputs=['y'], ) x = np.random.randn(1, 1, 4, 5).astype(np.float32) y = np.squeeze(x) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_mul1(self): node = onnx.helper.make_node( 'Mul', inputs=['x', 'y'], outputs=['z'], ) x = np.array([1, 2, 3]).astype(np.float32).reshape([3, 1]) y = np.array([4, 5, 6]).astype(np.float32).reshape([3, 1]) z = x * y # expected output [4., 10., 18.] output = OnnxLoader.run_node(node, [x, y]) np.testing.assert_almost_equal(output['z'], z, decimal=5)
def test_unsqueeze_axis1(self): node = onnx.helper.make_node( 'Unsqueeze', inputs=['x'], outputs=['y'], axes=[1], ) x = np.random.randn(3, 1, 4, 5).astype(np.float32) y = np.expand_dims(x, axis=1) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_div2(self): node = onnx.helper.make_node( 'Div', inputs=['x', 'y'], outputs=['z'], ) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.random.rand(3, 4, 5).astype(np.float32) + 1.0 z = x / y output = OnnxLoader.run_node(node, [x, y]) np.testing.assert_almost_equal(output["z"], z, decimal=5)
def test_div1(self): node = onnx.helper.make_node( 'Div', inputs=['x', 'y'], outputs=['z'], ) x = np.array([3, 4]).astype(np.float32).reshape([2, 1]) y = np.array([1, 2]).astype(np.float32).reshape([2, 1]) z = x / y output = OnnxLoader.run_node(node, [x, y]) np.testing.assert_almost_equal(output["z"], z, decimal=5)
def test_leakyrelu(self): node = helper.make_node('LeakyRelu', inputs=['x'], outputs=['y'], alpha=0.1) x = np.array([-1, 0, 1]).astype(np.float32) # expected output [-0.1, 0., 1.] y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1 output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_onnx_hardsigmoid(self): default_alpha = 0.2 default_beta = 0.5 node = onnx.helper.make_node( 'HardSigmoid', inputs=['x'], outputs=['y'], ) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.clip(x * default_alpha + default_beta, 0, 1) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_matmul_3d(self): node = onnx.helper.make_node( 'MatMul', inputs=['a', 'b'], outputs=['c'], ) # 3d a = np.random.randn(2, 3, 4).astype(np.float32) b = np.random.randn(2, 4, 3).astype(np.float32) c = np.matmul(a, b) output = OnnxLoader.run_node(node, [a, b]) np.testing.assert_almost_equal(output["c"], c, decimal=5)
def test_onnx_flatten(self): node = onnx.helper.make_node( 'Flatten', inputs=['a'], outputs=['b'], ) shape = (5, 4, 3, 2) a = np.random.random_sample(shape).astype(np.float32) new_shape = (5, 24) b = np.reshape(a, new_shape) output = OnnxLoader.run_node(node, [a]) np.testing.assert_almost_equal(output["b"], b, decimal=5)
def test_gt(self): node = helper.make_node( 'Greater', inputs=['x', 'y'], outputs=['greater'], ) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.random.randn(3, 4, 5).astype(np.float32) z = np.greater(x, y) output = OnnxLoader.run_node(node, [x, y]) np.testing.assert_almost_equal(output['greater'], z, decimal=5)
def test_slice3_default_axes(self): node = onnx.helper.make_node( 'Slice', inputs=['x'], outputs=['y'], starts=[0, 0, 3], ends=[20, 10, 4], ) x = np.random.randn(20, 10, 5).astype(np.float32) y = x[:, :, 3:4] output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_shape(self): node = onnx.helper.make_node( 'Shape', inputs=['x'], outputs=['y'], ) x = np.array([ [1, 2, 3], [4, 5, 6], ]).astype(np.float32) y = np.array([ 2, 3, ]).astype(np.int64) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.array(x.shape).astype(np.int64) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_globalaveragepool(self): node = onnx.helper.make_node( 'GlobalAveragePool', inputs=['x'], outputs=['y'], ) x = np.random.randn(2, 3, 7, 5).astype(np.float32) spatial_shape = np.ndim(x) - 2 y = np.average(x, axis=tuple(range(spatial_shape, spatial_shape + 2))) for _ in range(spatial_shape): y = np.expand_dims(y, -1) output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_transpose(self): shape = (2, 3, 4) data = np.random.random_sample(shape).astype(np.float32) permutation = (0, 2, 1) node = onnx.helper.make_node('Transpose', inputs=['data'], outputs=['transposed'], perm=permutation) transposed = np.transpose(data, permutation) output = OnnxLoader.run_node(node, [data]) np.testing.assert_almost_equal(output["transposed"], transposed, decimal=5)
def test_slice2_neg(self): node = onnx.helper.make_node( 'Slice', inputs=['x'], outputs=['y'], axes=[0, 1], starts=[0, 0], ends=[2, -2], ) x = np.random.randn(20, 10, 5).astype(np.float32) y = x[0:2, 0:-2] output = OnnxLoader.run_node(node, [x]) np.testing.assert_almost_equal(output["y"], y, decimal=5)
def test_batch_norm(self): x = np.array([[[[-1, 0, 1]], [[2, 3, 4]]]]).astype(np.float32).reshape((3, 2, 1, 1)) s = np.array([1.0, 1.0]).astype(np.float32).reshape((2, 1)) bias = np.array([0, 0]).astype(np.float32).reshape((2, 1)) mean = np.array([0, 3]).astype(np.float32).reshape((2, 1)) var = np.array([1, 1.5]).astype(np.float32).reshape((2, 1)) y = self._batchnorm_test_mode(x, s, bias, mean, var).astype(np.float32) node = onnx.helper.make_node( 'BatchNormalization', inputs=['x', 's', 'bias', 'mean', 'var'], outputs=['y'], ) output = OnnxLoader.run_node(node, [x, s, bias, mean, var]) np.testing.assert_almost_equal(output["y"], y, decimal=3)
def test_constant(self): values = np.random.randn(5, 5).astype(np.float32) node = onnx.helper.make_node( 'Constant', inputs=[], outputs=['values'], value=onnx.helper.make_tensor( name='const_tensor', data_type=onnx.TensorProto.FLOAT, dims=values.shape, vals=values.flatten().astype(float), ), ) output = OnnxLoader.run_node(node, []) np.testing.assert_almost_equal(output["values"], values, decimal=5)