def test_penalty_update(self):
x = numpy.random.randn(10, 1).astype(numpy.float32)
def fct(x):
return numpy.sign(x) * 0.1 + (x * 0.9 * 2)
exp_loss = x - fct(x)
onx = function_onnx_graph('update_penalty_elastic_error',
target_opset=get_max_opset(),
dtype=numpy.float32,
l1=0.1,
l2=0.9)
oinf = OnnxInference(onx)
got = oinf.run({'X': x})
self.assertEqualArray(exp_loss, got['Y'], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
got = sess.run(None, {'X': x})
self.assertEqualArray(exp_loss, got[0], decimal=5)
def test_penalty_3w(self):
loss = numpy.random.randn(1, 1).astype(numpy.float32)
w1 = numpy.random.randn(10, 1).astype(numpy.float32)
w2 = numpy.random.randn(5, 1).astype(numpy.float32)
def fct(x):
return numpy.abs(x).sum() * 0.1 + ((x)**2).sum() * 0.9
exp_loss = loss + fct(w1) + fct(w2)
onx = function_onnx_graph('n_penalty_elastic_error',
target_opset=get_max_opset(),
dtype=numpy.float32,
n_tensors=2,
l1_weight=0.1,
l2_weight=0.9,
weight_name='weight')
oinf = OnnxInference(onx)
got = oinf.run({'loss': loss, 'W0': w1, 'W1': w2})
self.assertEqualArray(exp_loss.reshape((-1, )), got['Y'], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
got = sess.run(None, {'loss': loss, 'W0': w1, 'W1': w2})
self.assertEqualArray(exp_loss.reshape((-1, )), got[0], decimal=5)
def common_check(self, name, fct, weight_name=None, output_name='Y'):
onx = function_onnx_graph(name,
target_opset=get_max_opset(),
dtype=numpy.float32,
weight_name=weight_name)
expected = numpy.random.randn(10, 1).astype(numpy.float32)
predicted = numpy.random.randn(10, 1).astype(numpy.float32)
w = numpy.random.rand(10).astype(numpy.float32)
if weight_name is None:
fin = fct(expected, predicted)
else:
fin = fct(expected, predicted, w)
oinf = OnnxInference(onx)
if weight_name is None:
got = oinf.run({'X1': expected, 'X2': predicted})
else:
got = oinf.run({'X1': expected, 'X2': predicted, 'weight': w})
self.assertEqualArray(fin, got[output_name], decimal=5)
if weight_name is not None:
got = oinf.run({'X1': expected, 'X2': predicted})
fin1 = fct(expected, predicted,
numpy.array([1], dtype=expected.dtype))
self.assertEqualArray(fin1, got[output_name], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
if weight_name is None:
got = sess.run(None, {'X1': expected, 'X2': predicted})
else:
got = sess.run(None, {
'X1': expected,
'X2': predicted,
'weight': w
})
self.assertEqualArray(fin, got[0], decimal=5)
if weight_name is not None:
got = sess.run(None, {'X1': expected, 'X2': predicted})
fin1 = fct(expected, predicted,
numpy.array([1], dtype=expected.dtype))
self.assertEqualArray(fin1, got[0], decimal=5)
def test_251(self):
onx = function_onnx_graph("grad_loss_square_error",
target_opset=get_max_opset(),
dtype=numpy.float32,
weight_name='weight')
expected = numpy.random.randn(25, 1).astype(numpy.float32)
predicted = numpy.random.randn(25, 1).astype(numpy.float32)
oinf = OnnxInference(onx)
got1 = oinf.run({'X1': expected, 'X2': predicted})
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=['CPUExecutionProvider'])
got2 = sess.run(None, {'X1': expected, 'X2': predicted})
self.assertEqualArray(got1['Y'], got2[0], decimal=5)
self.assertEqualArray(got1['Y_grad'], got2[1])
def common_unary(self, name, fct):
onx = function_onnx_graph(name,
target_opset=get_max_opset(),
dtype=numpy.float32)
x = numpy.random.randn(10, 1).astype(numpy.float32)
fin = fct(x)
oinf = OnnxInference(onx)
got = oinf.run({'X': x})
self.assertEqualArray(fin, got['Y'], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
got = sess.run(None, {'X': x})
self.assertEqualArray(fin, got[0], decimal=5)
def common_check_1(self, name, fct, weight_name=None, **kwargs):
onx = function_onnx_graph(name,
target_opset=get_max_opset(),
dtype=numpy.float32,
weight_name=weight_name,
**kwargs)
x = numpy.random.randn(10, 1).astype(numpy.float32)
exp_loss, exp_grad = fct(x)
oinf = OnnxInference(onx)
got = oinf.run({'X': x})
self.assertEqualArray(exp_loss, got['Y'], decimal=5)
self.assertEqualArray(exp_grad, got['Y_grad'], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
got = sess.run(None, {'X': x})
self.assertEqualArray(exp_loss, got[0], decimal=5)
self.assertEqualArray(exp_grad, got[1], decimal=5)
def common_check_alpha_beta(self, name, fct):
onx = function_onnx_graph(name,
target_opset=get_max_opset(),
dtype=numpy.float32)
x1 = numpy.random.randn(10, 1).astype(numpy.float32)
x2 = numpy.random.randn(10, 1).astype(numpy.float32)
g = numpy.random.randn(10, 1).astype(numpy.float32)
alpha = numpy.random.randn(1).astype(numpy.float32)
beta = numpy.random.randn(1).astype(numpy.float32)
y, z = fct(x1, x2, g, alpha, beta)
oinf = OnnxInference(onx)
got = oinf.run({
'X1': x1,
'X2': x2,
'alpha': alpha,
'beta': beta,
'G': g
})
self.assertEqualArray(y, got['Y'], decimal=5)
self.assertEqualArray(z, got['Z'], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
got = sess.run(None, {
'X1': x1,
'X2': x2,
'alpha': alpha,
'beta': beta,
'G': g
})
self.assertEqualArray(y, got[0], decimal=5)
self.assertEqualArray(z, got[1], decimal=5)
def common_check_3(self, name, fct):
onx = function_onnx_graph(name,
target_opset=get_max_opset(),
dtype=numpy.float32)
x = numpy.random.randn(10, 1).astype(numpy.float32)
a = numpy.random.randn(10, 1).astype(numpy.float32).T
b = numpy.random.randn(10, 1).astype(numpy.float32)
y = fct(x, a, b)
code = export2onnx(onx)
self.assertIn("'OnnxAdd'", code)
oinf = OnnxInference(onx)
got = oinf.run({'X': x, 'A': a, 'B': b})
self.assertEqualArray(y, got['Y'], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
got = sess.run(None, {'X': x, 'A': a, 'B': b})
self.assertEqualArray(y, got[0], decimal=5)
def test_exc(self):
self.assertRaise(lambda: function_onnx_graph("H"))
def common_check_2(self,
name,
fct,
weight_name=None,
verbose=0,
classification=False,
rnd=True,
second_name='Y_grad',
**kwargs):
onx = function_onnx_graph(name,
target_opset=get_max_opset(),
dtype=numpy.float32,
weight_name=weight_name,
**kwargs)
if verbose > 0:
with open(name + ".onnx", "wb") as f:
f.write(onx.SerializeToString())
if classification:
N = 10
p = numpy.random.randn(N, 1).astype(numpy.float32)
p[0, :] = 0
p[1, :] = 100
p[2, :] = -100
p[3, :] = 1
p[4, :] = -1
y = (numpy.random.randn(N, 1).astype(numpy.float32) > 0).astype(
numpy.int64)
x2 = p
x1 = y
else:
if rnd:
x1 = numpy.random.randn(10, 1).astype(numpy.float32)
x2 = numpy.random.randn(10, 1).astype(numpy.float32)
else:
x1 = numpy.zeros((10, 1), dtype=numpy.float32)
x2 = numpy.zeros((10, 1), dtype=numpy.float32) + 1
if rnd:
w = numpy.random.rand(10).astype(numpy.float32)
else:
w = numpy.zeros(10, dtype=numpy.float32) + 0.2
if weight_name is None:
exp_loss, exp_grad = fct(x1, x2)
else:
exp_loss, exp_grad = fct(x1, x2, w.reshape((-1, 1)))
oinf = OnnxInference(onx)
run_params = dict(verbose=verbose, fLOG=print) if verbose > 0 else {}
if verbose > 0:
print(f"\n+++++ name(1)={name!r}")
if weight_name is None:
got = oinf.run({'X1': x1, 'X2': x2}, **run_params)
else:
got = oinf.run({'X1': x1, 'X2': x2, 'weight': w}, **run_params)
self.assertEqual(len(exp_grad.shape), 2)
self.assertEqual(exp_grad.shape[-1], 1)
self.assertEqualArray(exp_grad, got[second_name], decimal=5)
self.assertEqualArray(exp_loss, got['Y'], decimal=5)
providers = device_to_providers('cpu')
so = SessionOptions()
so.log_severity_level = 0 if verbose > 0 else 4
so.log_verbosity_level = 0 if verbose > 0 else 4
sess = InferenceSession(onx.SerializeToString(),
so,
providers=providers)
if verbose > 0:
print("+++ run")
if weight_name is None:
got = sess.run(None, {'X1': x1, 'X2': x2})
else:
got = sess.run(None, {'X1': x1, 'X2': x2, 'weight': w})
self.assertEqualArray(exp_loss, got[0], decimal=5)
self.assertEqualArray(exp_grad, got[1], decimal=5)
if weight_name is not None:
if verbose > 0:
print("+++ run*")
got = sess.run(None, {'X1': x1, 'X2': x2})
exp_loss2, exp_grad2 = fct(x1, x2, numpy.array([1],
dtype=x1.dtype))
self.assertEqualArray(exp_loss2, got[0], decimal=5)
self.assertEqualArray(exp_grad2, got[1], decimal=5)
if 'grad' in name:
rew = unreduced_onnx_loss(onx)
if 'ReduceSum' in str(rew):
raise AssertionError(f"Isse with:\n{rew!r}")
if verbose > 0:
with open(name + ".unreduced.onnx", "wb") as f:
f.write(rew.SerializeToString())
if verbose > 0:
print(f"\n+++++ name(2)={name!r}")
oinf = OnnxInference(rew)
if weight_name is None:
got = oinf.run({'X1': x1, 'X2': x2}, **run_params)
else:
got = oinf.run({'X1': x1, 'X2': x2, 'weight': w}, **run_params)
score = got['score']
self.assertEqual(len(score.shape), 2)
self.assertEqual(score.shape[0], 10)
self.assertEqual(score.shape[1], 1)
self.assertEqualFloat(exp_loss, score.sum())
sess = InferenceSession(rew.SerializeToString(),
so,
providers=providers)
if verbose > 0:
print("+++ run")
if weight_name is None:
got = sess.run(None, {'X1': x1, 'X2': x2})
else:
got = sess.run(None, {'X1': x1, 'X2': x2, 'weight': w})
score = got[0]
self.assertEqual(len(score.shape), 2)
self.assertEqual(score.shape[0], 10)
self.assertEqual(score.shape[1], 1)
self.assertEqualFloat(exp_loss, score.sum())
This function implements :math:`Y = f(X1, X2, \\alpha) = \\alpha X1 + X2`.
"""
import numpy
from scipy.special import expit
import pandas
from tqdm import tqdm
from cpyquickhelper.numbers.speed_measure import measure_time
import matplotlib.pyplot as plt
from onnxruntime import InferenceSession
from onnxruntime.capi._pybind_state import ( # pylint: disable=E0611
SessionIOBinding, OrtDevice as C_OrtDevice, OrtValue as C_OrtValue)
from mlprodict.plotting.text_plot import onnx_simple_text_plot
from onnxcustom.utils.onnx_function import function_onnx_graph
fct_onx = function_onnx_graph("axpy")
print(onnx_simple_text_plot(fct_onx))
###########################################
# The numpy implementation is the following.
fct_numpy = lambda X1, X2, alpha: X1 * alpha + X2
###########################################
# The benchmark
def reshape(a, dim):
if len(a.shape) == 2:
return a[:dim].copy()
return a