def test_kernel_cosine_float(self):
ker = PairwiseKernel(metric='cosine')
# X, X
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
target_opset=TARGET_OPSET)
x = np.random.randn(4, 3)
x[0, 0] = x[1, 1] = x[2, 2] = 10.
x[3, 2] = 5.
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': x.astype(np.float32)})[0]
m1 = res
m2 = ker(x)
assert_almost_equal(m1, m2, decimal=5)
# X, x
onx = convert_kernel(ker, 'X', x_train=x,
output_names=['Y'], dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
target_opset=TARGET_OPSET)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': x.astype(np.float32)})[0]
m1 = res
m2 = ker(x)
assert_almost_equal(m1, m2, decimal=5)
def test_kernel_ker2_exp_sine_squared(self):
ker = ExpSineSquared()
onx = convert_kernel(ker,
'X',
output_names=['Y'],
dtype=np.float32,
op_version=onnx_opset_version())
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=4)
onx = convert_kernel(ker,
'X',
output_names=['Z'],
x_train=Xtest_ * 2,
dtype=np.float32,
op_version=onnx_opset_version())
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_, Xtest_ * 2)
assert_almost_equal(m1, m2, decimal=4)
def test_kernel_rational_quadratic(self):
ker = RationalQuadratic()
onx = convert_kernel(ker,
'X',
output_names=['Y'],
dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))],
target_opset=_TARGET_OPSET_)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=5)
onx = convert_kernel(ker,
'X',
output_names=['Z'],
x_train=(Xtest_ * 2).astype(np.float32),
dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))])
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_, Xtest_ * 2)
assert_almost_equal(m1, m2, decimal=3)
def test_kernel_dot_product(self):
ker = DotProduct()
onx = convert_kernel(ker,
'X',
output_names=['Y'],
dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1 / 1000, m2 / 1000, decimal=5)
onx = convert_kernel(ker,
'X',
output_names=['Z'],
x_train=Xtest_ * 2,
dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_, Xtest_ * 2)
assert_almost_equal(m1 / 1000, m2 / 1000, decimal=5)
def test_kernel_ker2_def_ort(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3)))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=get_opset_number_from_onnx())
model_onnx.ir_version = get_ir_version_from_onnx()
sess = _capture_output(
lambda: OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime2"), 'c')[0]
try:
res = sess.run({'X': Xtest_.astype(numpy.float32)})
except RuntimeError as e:
if "Got invalid dimensions for input" in str(e):
# probable bug somewhere
return
raise e
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2, decimal=5)
def test_kernel_rbf1(self):
ker = RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))])
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=5)
def test_kernel_constant1(self):
ker = C(5.)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=5)
def test_kernel_exp_sine_squared(self):
from skl2onnx.operator_converters.gaussian_process import convert_kernel
ker = ExpSineSquared()
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))])
sess = OnnxInference(model_onnx)
Xtest_ = numpy.arange(6).reshape((3, 2))
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2, decimal=5)
def test_kernel_rbf1(self):
from skl2onnx.operator_converters.gaussian_process import convert_kernel
ker = RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))])
sess = OnnxInference(model_onnx)
Xtest_ = numpy.arange(6).reshape((3, 2))
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2)
def test_kernel_rbf_mul(self):
ker = (C(1.0, constant_value_bounds="fixed") *
RBF(1.0, length_scale_bounds="fixed"))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))])
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=5)
def test_kernel_ker12_def(self):
ker = (Sum(CK(0.1, (1e-3, 1e3)), CK(0.1, (1e-3, 1e3)) *
RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))])
sess = OnnxInference(model_onnx.SerializeToString())
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2)
def test_kernel_ker12_def(self):
ker = (Sum(C(0.1, (1e-3, 1e3)), C(0.1, (1e-3, 1e3)) *
RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
target_opset=_TARGET_OPSET_)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=5)
def test_kernel_ker2_def_ort1(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3))
)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))])
sess = OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime1")
rows = []
def myprint(*args, **kwargs):
rows.append(" ".join(map(str, args)))
res = sess.run({'X': Xtest_.astype(numpy.float32)},
intermediate=True, verbose=1, fLOG=myprint)
self.assertGreater(len(rows), 2)
m1 = res['Y']
self.assertNotEmpty(m1)
self.assertGreater(len(res), 2)
# m2 = ker(Xtest_)
# self.assertEqualArray(m1, m2, decimal=5)
cpu = OnnxInference(model_onnx.SerializeToString())
sbs = side_by_side_by_values(
[cpu, sess], inputs={'X': Xtest_.astype(numpy.float32)})
self.assertGreater(len(sbs), 2)
self.assertIsInstance(sbs, list)
self.assertIsInstance(sbs[0], dict)
self.assertIn('step', sbs[0])
self.assertIn('step', sbs[1])
self.assertIn('metric', sbs[0])
self.assertIn('metric', sbs[1])
self.assertIn('cmp', sbs[0])
self.assertIn('cmp', sbs[1])
sess3 = OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime2")
sbs = side_by_side_by_values(
[cpu, sess, sess3], inputs={'X': Xtest_.astype(numpy.float32)})
self.assertNotEmpty(sbs)
inputs = {'X': Xtest_.astype(numpy.float32)}
sbs = side_by_side_by_values(
[(cpu, inputs), (sess, inputs), (sess3, inputs)])
self.assertNotEmpty(sbs)
def test_kernel_ker2_dotproduct(self):
ker = DotProduct(sigma_0=2.)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType())],
outputs=[('Y', FloatTensorType())],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
x = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
res = sess.run(None, {'X': x})
m1 = res[0]
m2 = ker(x)
assert_almost_equal(m1, m2, decimal=5)
res = sess.run(None, {'X': Xtest_.astype(np.float32)})
m1 = res[0]
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=2)
def test_kernel_cosine_double(self):
ker = PairwiseKernel(metric='cosine')
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float64,
op_version=_TARGET_OPSET_)
model_onnx = onx.to_onnx(
inputs=[('X', DoubleTensorType([None, None]))],
target_opset=TARGET_OPSET)
x = np.random.randn(4, 3)
x[0, 0] = x[1, 1] = x[2, 2] = 10.
x[3, 2] = 5.
try:
sess = InferenceSession(model_onnx.SerializeToString())
except NotImplemented:
# Failed to find kernel for FusedMatMul(1).
return
res = sess.run(None, {'X': x.astype(np.float64)})[0]
m1 = res
m2 = ker(x)
assert_almost_equal(m1, m2, decimal=5)
def test_kernel_ker2_def(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3))
)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=get_opset_number_from_onnx())
sess = OnnxInference(model_onnx.SerializeToString())
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2)
res = sess.run({'X': Xtest_.astype(numpy.float32)}, intermediate=True)
self.assertGreater(len(res), 30)
self.assertIsInstance(res, dict)
def test_kernel_ker2_def_ort1(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3))
)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=get_opset_number_from_onnx())
model_onnx.ir_version = get_ir_version_from_onnx()
sess = OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime1")
rows = []
def myprint(*args, **kwargs):
rows.append(" ".join(map(str, args)))
res = _capture_output(
lambda: sess.run({'X': Xtest_.astype(numpy.float32)},
intermediate=True, verbose=1, fLOG=myprint),
'c')[0]
self.assertGreater(len(rows), 2)
m1 = res['Y']
self.assertNotEmpty(m1)
self.assertGreater(len(res), 2)
# m2 = ker(Xtest_)
# self.assertEqualArray(m1, m2, decimal=5)
cpu = OnnxInference(model_onnx.SerializeToString())
sbs = side_by_side_by_values(
[cpu, sess], inputs={'X': Xtest_.astype(numpy.float32)})
self.assertGreater(len(sbs), 2)
self.assertIsInstance(sbs, list)
self.assertIsInstance(sbs[0], dict)
self.assertIn('step', sbs[0])
self.assertIn('step', sbs[1])
self.assertIn('metric', sbs[0])
self.assertIn('metric', sbs[1])
self.assertIn('cmp', sbs[0])
self.assertIn('cmp', sbs[1])
sess3 = _capture_output(
lambda: OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime2"), 'c')[0]
try:
sbs = side_by_side_by_values(
[cpu, sess, sess3], inputs={'X': Xtest_.astype(numpy.float32)})
except RuntimeError as e:
if "Got invalid dimensions for input" in str(e):
# probable bug somewhere
return
raise e
self.assertNotEmpty(sbs)
inputs = {'X': Xtest_.astype(numpy.float32)}
sbs = side_by_side_by_values(
[(cpu, inputs), (sess, inputs), (sess3, inputs)])
self.assertNotEmpty(sbs)
