def test_reshape_with_copy(self): x = self._get_rnd([10, 20 * 30]) shape = [0, 20, 30] if defs.onnx_opset_version() < 5: node_def = helper.make_node("Reshape", ["X"], ["Z"], shape=shape) output = run_node(node_def, [x]) else: node_def = helper.make_node("Reshape", ["X", "Y"], ["Z"]) output = run_node(node_def, [x, shape]) np.testing.assert_almost_equal(output["Z"], x.reshape([10, 20, 30]))
def test_average_pool(self): # TODO: fix this test return device = "CUDA" if not supports_device(device): raise unittest.SkipTest( "Backend doesn't support device {}".format(device)) shape = [1, 1, 40, 40] node_def = helper.make_node("AveragePool", ["X"], ["Y"], kernel_shape=[1, 2], pads=[1, 1], strides=[1, 1]) x = self._get_rnd(shape) output = run_node(node_def, [x], device=device) test_output = np.zeros(shape) for i1 in range(0, shape[0]): for i2 in range(0, shape[1]): for j1 in range(0, shape[2]): for j2 in range(0, shape[3]): test_output[i1][i2][j1][j2] = 0 count = 0 for k in range(j2, min(j2 + 2, shape[3])): test_output[i1][i2][j1][j2] += x[i1][i2][j1][k] count += 1 test_output[i1][i2][j1][j2] /= count np.testing.assert_almost_equal(output["Y"], test_output)
def test_cast(self): if legacy_onnx_pre_1_2() or legacy_opset_pre_6(): test_cases = [("FLOAT", tf.float32), ("UINT8", tf.uint8), ("INT8", tf.int8), ("UINT16", tf.uint16), ("INT16", tf.int16), ("INT32", tf.int32), ("INT64", tf.int64), ("BOOL", tf.bool), ("FLOAT16", tf.float16), ("DOUBLE", tf.float64), ("COMPLEX64", tf.complex64), ("COMPLEX128", tf.complex128)] else: test_cases = [(TensorProto.FLOAT, tf.float32), (TensorProto.UINT8, tf.uint8), (TensorProto.INT8, tf.int8), (TensorProto.UINT16, tf.uint16), (TensorProto.INT16, tf.int16), (TensorProto.INT32, tf.int32), (TensorProto.INT64, tf.int64), (TensorProto.BOOL, tf.bool), (TensorProto.FLOAT16, tf.float16), (TensorProto.DOUBLE, tf.float64), (TensorProto.COMPLEX64, tf.complex64), (TensorProto.COMPLEX128, tf.complex128)] for ty, tf_type in test_cases: node_def = helper.make_node("Cast", ["input"], ["output"], to=ty) vector = [2, 3] output = run_node(node_def, [vector]) np.testing.assert_equal(output["output"].dtype, tf_type)
def test_less(self): node_def = helper.make_node("Less", ["X", "Y"], ["Z"]) x = self._get_rnd([5, 3, 3, 2]) y = self._get_rnd([3, 3, 1]) output = run_node(node_def, [x, y]) np.testing.assert_equal(output["Z"], np.less(x, np.reshape(y, [1, 3, 3, 1])))
def test_conv_transpose(self): # Fix test in the future. return device = "CUDA" if not supports_device(device): raise unittest.SkipTest( "Backend doesn't support device {}".format(device)) node_def = helper.make_node("ConvTranspose", ["X", "weights"], ["Y"], pads=[1, 1]) x_shape = [1, 5, 4] x = self._get_rnd(x_shape) weight_shape = [5, 3, 2] weights = self._get_rnd(weight_shape) output = run_node(node_def, [x, weights], device=device) out_shape = [x_shape[0], weight_shape[1], x_shape[2]] test_output = np.zeros(out_shape) for b in range(0, x_shape[0]): for m in range(0, weight_shape[1]): for h in range(0, x_shape[2]): v = 0 for c in range(0, x_shape[1]): for k in range(h, min(h + weight_shape[2], x_shape[2])): v += x[b][c][k] * weights[c][m][k - h] test_output[b][m][h] = v np.testing.assert_almost_equal(output["Y"], test_output, decimal=5)
def test_reduce_sum(self): node_def = helper.make_node("ReduceSum", ["X"], ["Y"], axes=[1, 2]) x = self._get_rnd([5, 10, 10, 3]) output = run_node(node_def, [x]) np.testing.assert_allclose(output["Y"], np.sum(x, (1, 2), keepdims=True), rtol=1e-3)
def test_slice(self): # TODO: API update or fix onnx version return node_def = helper.make_node("Slice", ["X", "Y", "Z", "W"], ["S"]) x = self._get_rnd([1000]).reshape([10, 10, 10]) output = run_node(node_def, [x, [0, 1, 2], [0, 0, 0], [2, 2, 2]]) np.testing.assert_almost_equal(output["S"], x[0:2, 0:2, 0:2])
def test_mul(self): node_def = helper.make_node("Mul", ["X", "Y"], ["Z"]) x = self._get_rnd([5, 10, 5, 5]) y = self._get_rnd([10, 1, 1]) output = run_node(node_def, [x, y]) np.testing.assert_almost_equal( output["Z"], np.multiply(x, y.reshape([1, 10, 1, 1])))
def test_lp_normalization(self): node_def = helper.make_node("LpNormalization", ["X"], ["Y"]) x = self._get_rnd([5, 3, 3, 2]) output = run_node(node_def, [x]) np.testing.assert_allclose(output["Y"], np.expand_dims(np.linalg.norm(x, axis=-1), -1), rtol=1e-3)
def test_min(self): node_def = helper.make_node("Min", ["X1", "X2", "X3", "X4"], ["Z"]) x1 = self._get_rnd([10, 10]) x2 = self._get_rnd([10, 10]) x3 = self._get_rnd([10, 10]) x4 = self._get_rnd([10, 10]) output = run_node(node_def, [x1, x2, x3, x4]) test_output = np.minimum(np.minimum(np.minimum(x1, x2), x3), x4) np.testing.assert_almost_equal(output["Z"], test_output)
def test_constant(self): shape = [16, 16] values = np.random.randn(*shape).flatten().astype(float) const2_onnx = helper.make_tensor("const2", TensorProto.DOUBLE, shape, values) node_def = helper.make_node("Constant", [], ["Y"], value=const2_onnx) output = run_node(node_def, []) np.testing.assert_equal(output["Y"].shape, shape) np.testing.assert_almost_equal(output["Y"].flatten(), values)
def test_selu(self): node_def = helper.make_node("Selu", ["X"], ["Y"]) x = self._get_rnd([1000]) output = run_node(node_def, [x]) alpha = 1.6732 gamma = 1.0507 x[x <= 0] = gamma * (alpha * np.exp(x[x <= 0]) - alpha) x[x > 0] = gamma * x[x > 0] np.testing.assert_allclose(output["Y"], x, rtol=1e-3, atol=1e-7)
def test_dot(self): # this op is removed # remove this test in the future return node_def = helper.make_node("Dot", ["X", "Y"], ["Z"]) x = np.floor(self._get_rnd([10, 10])) y = np.floor(self._get_rnd([10, 10])) output = run_node(node_def, [x, y]) np.testing.assert_almost_equal(output["Z"], np.dot(x, y))
def test_sum(self): node_def = helper.make_node("Sum", ["X1", "X2", "X3", "X4"], ["Z"]) x1 = self._get_rnd([10, 10]) x2 = self._get_rnd([10, 10]) x3 = self._get_rnd([10, 10]) x4 = self._get_rnd([10, 10]) output = run_node(node_def, [x1, x2, x3, x4]) test_output = x1 + x2 + x3 + x4 np.testing.assert_almost_equal(output["Z"], test_output)
def test_space_to_depth(self): node_def = helper.make_node("SpaceToDepth", ["X"], ["Y"], blocksize=2) x_shape = [1, 3, 2, 2] x = self._get_rnd(x_shape) output = run_node(node_def, [x]) x = np.transpose(x, (0, 2, 3, 1)) y = np.reshape(np.swapaxes(x.reshape(1, 1, 1, 1, 1, 12), 2, 3), (1, 1, 1, 12)) y = np.transpose(y, (0, 3, 1, 2)) np.testing.assert_allclose(output["Y"], y, rtol=1e-3)
def test_depth_to_space(self): node_def = helper.make_node("DepthToSpace", ["X"], ["Y"], blocksize=2) x_shape = [1, 12, 1, 1] x = self._get_rnd(x_shape) output = run_node(node_def, [x]) x = np.transpose(x, (0, 2, 3, 1)) y = np.reshape(np.swapaxes(x.reshape(1, 1, 1, 2, 2, 3), 2, 3), (1, 2, 2, 3)) y = np.transpose(y, (0, 3, 1, 2)) np.testing.assert_almost_equal(output["Y"], y, decimal=5)
def test_tile(self): if legacy_onnx_pre_1_2(): raise unittest.SkipTest( "The current version of ONNX does not record correctly the opset of Tile." ) node_def = helper.make_node("Tile", ["X1", "X2"], ["Z"]) x = self._get_rnd([3, 5, 5, 3]) repeats = [1, 1, 2, 1] output = run_node(node_def, [x, repeats]) np.testing.assert_allclose(output["Z"], np.tile(x, repeats), rtol=1e-3)
def test_concat(self): shape = [10, 20, 5] for axis in range(len(shape)): node_def = helper.make_node("Concat", ["X1", "X2"], ["Y"], axis=axis) x1 = self._get_rnd(shape) x2 = self._get_rnd(shape) output = run_node(node_def, [x1, x2]) np.testing.assert_almost_equal(output["Y"], np.concatenate((x1, x2), axis))
def test_reduce_log_sum_exp(self): node_def = helper.make_node("ReduceLogSumExp", ["X"], ["Y"], axes=[1, 2]) x = self._get_rnd([5, 10, 10, 3]) output = run_node(node_def, [x]) np.testing.assert_allclose(output["Y"], np.log( np.sum(np.exp(x), axis=(1, 2), keepdims=True)), rtol=1e-3)
def test_pad(self): node_def = helper.make_node("Pad", ["X"], ["Y"], mode="constant", pads=[1, 1, 1, 1], value=2.0) x = self._get_rnd([100, 100]) output = run_node(node_def, [x]) np.testing.assert_almost_equal( output["Y"], np.lib.pad(x, ((1, 1), (1, 1)), 'constant', constant_values=(2, 2)))
def test_arg_min(self): # TODO: need to fix this test return for axis in [0, 1]: node_def = helper.make_node("ArgMin", ["data"], ["reduced"], axis=axis, keepdims=0) data = self._get_rnd([10, 10]) output = run_node(node_def, [data]) np.testing.assert_almost_equal(output["reduced"], np.argmin(data, axis=axis))
def test_split(self): split = [3, 3, 4] node_def = helper.make_node("Split", ["X"], ["Z%i" % i for i in range(len(split))], axis=0, split=split) x = self._get_rnd([100]).reshape([10, 10]) output = run_node(node_def, [x]) for a, b in zip(list(output), np.split(x, np.cumsum(split))[:-1]): np.testing.assert_almost_equal(a, b)
def test_gather(self): node_def = helper.make_node("Gather", ["X", "Y"], ["Z"]) x = self._get_rnd([10, 10]) y = [[0, 1], [1, 2]] output = run_node(node_def, [x, y]) test_output = np.zeros((2, 2, 10)) for i in range(0, 2): for j in range(0, 10): test_output[0][i][j] = x[i][j] for i in range(0, 2): for j in range(0, 10): test_output[1][i][j] = x[i + 1][j] np.testing.assert_almost_equal(output["Z"], test_output)
def test_gemm(self): # Compute Y = alpha * A * B + beta * C node_def = helper.make_node("Gemm", ["A", "B", "C"], ["Y"], transA=0, transB=0, alpha=1.0, beta=1.0) x = np.floor(self._get_rnd([10, 10])) y = np.floor(self._get_rnd([10, 10])) z = np.floor(self._get_rnd([10, 10])) output = run_node(node_def, [x, y, z]) test_output = np.matmul(x, y) + z np.testing.assert_almost_equal(output["Y"], test_output)
def test_flatten(self): # If input tensor has shape (d_0, d_1, ... d_n) then the # output will have shape: # # (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn) # # TODO: pass axis attribute which is supported in newer # versions of onnx node_def = helper.make_node("Flatten", ["X"], ["Y"]) x = self._get_rnd([10, 2, 3, 4, 5]) output = run_node(node_def, [x]) # TODO: pass axis=3 and uncomment the line below # np.testing.assert_almost_equal(output["Y"], x.reshape([60, 20])) np.testing.assert_almost_equal(output["Y"], x.reshape([10, 120]))
def test_max_pool(self): return node_def = helper.make_node("MaxPool", ["X"], ["Y"], dilations=[1, 1], kernel_shape=[1, 2], pads=[0, 0], strides=[1, 2]) x = self._get_rnd([10, 10, 4, 4]) output = run_node(node_def, [x]) test_output = np.zeros([10, 10, 4, 2]) for i1 in range(0, 10): for i2 in range(0, 10): for j1 in range(0, 4): for j2 in range(0, 2): test_output[i1][i2][j1][j2] = \ max(x[i1][i2][j1][2*j2], x[i1][i2][j1][2*j2 + 1]) np.testing.assert_almost_equal(output["Y"], test_output)
def test_constant_fill(self): shape = [1, 2, 3, 4] extra_shape = [5, 6] value = 3. node_def = helper.make_node( "ConstantFill", ["X"], ["Y"], value=value, extra_shape=extra_shape, dtype=1, ) x = self._get_rnd(shape) y = np.zeros(shape + extra_shape) y.fill(value) output = run_node(node_def, [x]) np.testing.assert_equal(output["Y"].dtype, tf.float32) np.testing.assert_equal(output["Y"], y)
def test_image_sacler(self): # Input: (N x C x H x W), where N is the batch size, # C is the number of channels, and H and W are the height # and the width of the data # Scale: (flout, default 1.0) the scale to apply # Bias: applied to each channel, same size as C # Output has same shape and type as input x = self._get_rnd([1, 3, 224, 224]) #random distribution over [0,1), so add 0.1 scale = np.random.rand(1)[0] + 0.1 bias = np.random.rand(3) node_def = helper.make_node("ImageScaler", ["X"], ["Y"], scale=scale, bias=bias) output = run_node(node_def, [x]) test_out = np.multiply(x, scale) test_out = np.transpose(test_out, [0, 2, 3, 1]) test_out = np.add(test_out, bias) test_out = np.transpose(test_out, [0, 3, 1, 2]) np.testing.assert_almost_equal(output["Y"], test_out)
def test_global_lp_pool(self): # Image case: (N x C x H x W), where N is the batch size, # C is the number of channels, and H and W are the height # and the width of the data # # Non-image case: (N x C x D1 x D2 ... Dn) # # Output data tensor from pooling across the input tensor. # Dimensions will be N x C x 1 x 1 node_def = helper.make_node("GlobalLpPool", ["X"], ["Y"]) x = self._get_rnd([10, 10, 2, 3]) output = run_node(node_def, [x]) test_output = np.zeros([10, 10, 1, 1]) for i1 in range(0, 10): for i2 in range(0, 10): tmp = np.zeros([2, 3]) for j1 in range(0, 2): for j2 in range(0, 3): tmp[j1][j2] = x[i1][i2][j1][j2] test_output[i1][i2][0][0] = np.linalg.norm(tmp) np.testing.assert_almost_equal(output["Y"], test_output, decimal=5)
def test_batch_normalization(self): if legacy_opset_pre_6(): raise unittest.SkipTest("Backend doesn't support consumed flag") node_def = helper.make_node("BatchNormalization", ["X", "scale", "bias", "mean", "var"], ["Y"], epsilon=0.001) x_shape = [3, 5, 4, 2] param_shape = [5] _param_shape = [1, 5, 1, 1] x = self._get_rnd(x_shape, 0, 1) m = self._get_rnd(param_shape, 0, 1) _m = m.reshape(_param_shape) v = self._get_rnd(param_shape, 0, 1) _v = v.reshape(_param_shape) scale = self._get_rnd(param_shape, 0, 1) _scale = scale.reshape(_param_shape) bias = self._get_rnd(param_shape, 0, 1) _bias = bias.reshape(_param_shape) golden = self._batch_normalization(x, _m, _v, _bias, _scale, 0.001) output = run_node(node_def, [x, scale, bias, m, v]) np.testing.assert_almost_equal(output["Y"], golden, decimal=5)