def build_ort_reducesumsquare(axes, op_version=14): # opset=13, 14, ...
node = OnnxReduceSumSquare('x',
axes=axes,
op_version=op_version,
output_names=['z'])
onx = node.to_onnx(inputs=[('x', FloatTensorType())],
target_opset=op_version)
sess = InferenceSession(onx.SerializeToString())
return lambda x, y: sess.run(None, {'x': x})
def test_onnxt_runtime_reduce_sum_square(self):
X = numpy.array([[2, 1], [0, 1]], dtype=float)
onx = OnnxReduceSumSquare('X', output_names=['Y'], keepdims=0)
model_def = onx.to_onnx({'X': X.astype(numpy.float32)})
oinf = OnnxInference(model_def)
got = oinf.run({'X': X})
self.assertEqual(list(sorted(got)), ['Y'])
self.assertEqualArray(numpy.sum(numpy.square(X)), got['Y'], decimal=6)
onx = OnnxReduceSumSquare('X', output_names=['Y'], axes=1)
model_def = onx.to_onnx({'X': X.astype(numpy.float32)})
oinf = OnnxInference(model_def)
got = oinf.run({'X': X})
self.assertEqual(list(sorted(got)), ['Y'])
self.assertEqualArray(
numpy.sum(numpy.square(X), axis=1).ravel(), got['Y'].ravel())
onx = OnnxReduceSumSquare('X', output_names=['Y'], axes=1, keepdims=1)
model_def = onx.to_onnx({'X': X.astype(numpy.float32)})
oinf = OnnxInference(model_def)
got = oinf.run({'X': X})
self.assertEqual(list(sorted(got)), ['Y'])
self.assertEqualArray(
numpy.sum(numpy.square(X), axis=1, keepdims=1).ravel(),
got['Y'].ravel())
def squareform_pdist(X, **kwargs):
opv = TARGET_OPSET
diff = OnnxSub('next_in',
'next',
output_names=['diff'],
op_version=opv)
id_next = OnnxIdentity('next_in',
output_names=['next_out'],
op_version=opv)
norm = OnnxReduceSumSquare(diff,
output_names=['norm'],
axes=[1],
op_version=opv)
flat = OnnxSqueezeApi11(norm,
output_names=['scan_out'],
axes=[1],
op_version=opv)
scan_body = id_next.to_onnx(
OrderedDict([('next_in', FloatTensorType()),
('next', FloatTensorType())]),
outputs=[('next_out', FloatTensorType([None, None])),
('scan_out', FloatTensorType([None]))],
other_outputs=[flat])
node = OnnxScan(X,
X,
output_names=['scan0_{idself}', 'scan1_{idself}'],
num_scan_inputs=1,
body=scan_body.graph,
op_version=opv,
**kwargs)
return node[1]
def _onnx_square_error(target_opset=None,
dtype=numpy.float32,
weight_name=None):
"""
Returns the ONNX graph for function
:math:`Y = f(X1, X2) = \\lVert X1 - X2 \\rVert ^2` or
:math:`Y = f(X1, X2) = \\lVert X1 - X2 \\rVert ^2 w` if
*weight_name* is not None
.. gdot::
:script: DOT-SECTION
from mlprodict.onnxrt import OnnxInference
from onnxcustom.utils.onnx_function import function_onnx_graph
model_onnx = function_onnx_graph('square_error')
oinf = OnnxInference(model_onnx, inplace=False)
print("DOT-SECTION", oinf.to_dot())
"""
from skl2onnx.algebra.onnx_ops import (OnnxSub, OnnxReduceSumSquare,
OnnxReshape, OnnxReduceSum, OnnxMul)
diff = OnnxSub('X1', 'X2', op_version=target_opset)
if weight_name is None:
res = OnnxReduceSumSquare(diff, op_version=target_opset)
else:
mul = OnnxMul(OnnxMul(diff, diff, op_version=target_opset),
OnnxReshape(weight_name,
numpy.array([-1, 1], dtype=numpy.int64),
op_version=target_opset),
op_version=target_opset)
res = OnnxReduceSum(mul, op_version=target_opset)
res = OnnxReshape(res,
numpy.array([-1], numpy.int64),
op_version=target_opset,
output_names=['Y'])
var_type = dtype_to_var_type(dtype)
varsx = [('X1', var_type([None, None])), ('X2', var_type([None, None]))]
if weight_name is not None:
varsx.append((weight_name, var_type([None])))
onx = res.to_onnx(varsx,
outputs=[('Y', var_type())],
target_opset=target_opset)
if weight_name is not None:
onx = add_initializer(onx, weight_name, numpy.array([1], dtype=dtype))
return onx
def test_onnx_example_pdist(self):
x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
opv = _TARGET_OPSET_
diff = OnnxSub('next_in',
'next',
output_names=['diff'],
op_version=opv)
id_next = OnnxIdentity('next_in',
output_names=['next_out'],
op_version=opv)
norm = OnnxReduceSumSquare(diff,
output_names=['norm'],
axes=[1],
op_version=opv)
flat = OnnxSqueezeApi11(norm,
output_names=['scan_out'],
axes=[1],
op_version=opv)
scan_body = id_next.to_onnx(OrderedDict([('next_in', x),
('next', FloatTensorType())]),
outputs=[
('next_out', FloatTensorType([3, 2])),
('scan_out', FloatTensorType([3]))
],
other_outputs=[flat],
target_opset=opv)
sess = InferenceSession(scan_body.SerializeToString())
res = sess.run(None, {'next_in': x, 'next': x[:1]})
assert_almost_equal(x, res[0])
exp = np.array([0., 18., 20.], dtype=np.float32)
assert_almost_equal(exp, res[1])
node = OnnxScan('x',
'x',
output_names=['y', 'z'],
num_scan_inputs=1,
body=scan_body.graph,
op_version=opv)
model_def = node.to_onnx({'x': x},
outputs=[('y', FloatTensorType([3, 2])),
('z', FloatTensorType([3, 3]))])
try:
onnx.checker.check_model(model_def)
except ValidationError as e:
if StrictVersion(onnx__version__) <= StrictVersion("1.5.0"):
warnings.warn(e)
else:
raise e
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'x': x})
exp = squareform(pdist(x, metric="sqeuclidean"))
assert_almost_equal(x, res[0])
assert_almost_equal(exp, res[1])
def test_onnx_example_pdist(self):
x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
diff = OnnxSub('next_in', 'next', output_names=['diff'])
id_next = OnnxIdentity('next_in', output_names=['next_out'])
norm = OnnxReduceSumSquare(diff, output_names=['norm'], axes=[1])
flat = OnnxSqueeze(norm, output_names=['scan_out'], axes=[1])
scan_body = id_next.to_onnx(OrderedDict([('next_in', x),
('next', FloatTensorType())]),
outputs=[
('next_out', FloatTensorType([3, 2])),
('scan_out', FloatTensorType([3]))
],
other_outputs=[flat])
sess = InferenceSession(scan_body.SerializeToString())
res = sess.run(None, {'next_in': x, 'next': x[:1]})
assert_almost_equal(x, res[0])
exp = np.array([0., 18., 20.], dtype=np.float32)
assert_almost_equal(exp, res[1])
node = OnnxScan('x',
'x',
output_names=['y', 'z'],
num_scan_inputs=1,
body=scan_body.graph)
model_def = node.to_onnx({'x': x},
outputs=[('y', FloatTensorType([3, 2])),
('z', FloatTensorType([3, 3]))])
try:
onnx.checker.check_model(model_def)
except ValidationError as e:
if sys.platform.startswith("win"):
# schema information in onnx is incomplete on Windows
warnings.warn(e)
else:
raise e
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'x': x})
exp = squareform(pdist(x, metric="sqeuclidean"))
assert_almost_equal(x, res[0])
assert_almost_equal(exp, res[1])
def conv(scope, operator, container):
X = operator.inputs[0]
out = operator.outputs
op = operator.raw_operator
C = op.cluster_centers_
C2 = row_norms(C, squared=True)
N = X.type.shape[0]
zeros = np.zeros((N, ))
rs = OnnxReduceSumSquare(X, axes=[1], keepdims=1)
z = OnnxAdd(rs, OnnxGemm(X, C, zeros, alpha=-2., transB=1))
y2 = OnnxAdd(C2, z)
lo = OnnxArgMin(y2, axis=1, keepdims=0, output_names=out[:1])
y2s = OnnxSqrt(y2, output_names=out[1:])
lo.add_to(scope, container)
y2s.add_to(scope, container)
def conv(scope, operator, container):
X = operator.inputs[0]
out = operator.outputs
op = operator.raw_operator
dtype = guess_numpy_type(X.type)
C = op.cluster_centers_
C2 = row_norms(C, squared=True).astype(dtype)
C = C.astype(dtype)
rs = OnnxReduceSumSquare(X,
axes=[1],
keepdims=1,
op_version=container.target_opset)
N = X.type.shape[0]
if isinstance(N, int):
zeros = np.zeros((N, ))
else:
zeros = OnnxMul(rs,
np.array([0], dtype=np.float32),
op_version=container.target_opset)
z = OnnxAdd(rs,
OnnxGemm(X,
C,
zeros,
alpha=-2.,
transB=1,
op_version=container.target_opset),
op_version=container.target_opset)
y2 = OnnxAdd(C2, z, op_version=container.target_opset)
lo = OnnxArgMin(y2,
axis=1,
keepdims=0,
output_names=out[:1],
op_version=container.target_opset)
y2s = OnnxSqrt(y2,
output_names=out[1:],
op_version=container.target_opset)
lo.add_to(scope, container)
y2s.add_to(scope, container)
def _onnx_n_penalty_elastic_error(target_opset=None,
dtype=numpy.float32,
weight_name=None,
l1_weight=0.01,
l2_weight=0.01,
n_tensors=1,
loss_shape=(1, 1)):
"""
Returns the ONNX graph for function
:math:`Y = f(W) = \\beta \\lVert W \\rVert +
\\alpha \\lVert W \\rVert^2`
*l1_weight* is :math:`\\beta` and
*l2_weight* is :math:`\\alpha`.
It does that for *n_tensors* and adds all of the results
to an input loss.
.. gdot::
:script: DOT-SECTION
from mlprodict.onnxrt import OnnxInference
from onnxcustom.utils.onnx_function import function_onnx_graph
model_onnx = function_onnx_graph(
'n_penalty_elastic_error', n_tensors=2)
oinf = OnnxInference(model_onnx, inplace=False)
print("DOT-SECTION", oinf.to_dot())
"""
from skl2onnx.algebra.onnx_ops import (OnnxMul, OnnxAdd,
OnnxReduceSumSquare, OnnxReduceSum,
OnnxAbs, OnnxReshape)
if n_tensors <= 0:
raise ValueError( # pragma: no cover
"This function is useless if the number of tensors is null.")
var_type = dtype_to_var_type(dtype)
varsx = [('loss', var_type(loss_shape))]
names = ['loss']
for n in range(n_tensors):
name = 'W%d' % n
abs_diff = OnnxAbs(name, op_version=target_opset)
res_l1 = OnnxReduceSum(abs_diff, op_version=target_opset)
# res2_l1 = OnnxSign(diff, op_version=target_opset)
res_l2 = OnnxReduceSumSquare(name, op_version=target_opset)
# res2_l2 = diff
res = OnnxAdd(OnnxMul(res_l1,
numpy.array([l1_weight], dtype=dtype),
op_version=target_opset),
OnnxMul(res_l2,
numpy.array([l2_weight], dtype=dtype),
op_version=target_opset),
op_version=target_opset)
names.append(res)
varsx.append(('W%d' % n, var_type()))
if len(names) == 2:
res = OnnxAdd(*names, op_version=target_opset)
else:
res = OnnxAdd(names[1], names[2], op_version=target_opset)
for i in range(3, len(names)):
res = OnnxAdd(res, names[i], op_version=target_opset)
res = OnnxAdd(names[0], res, op_version=target_opset)
res = OnnxReshape(res,
numpy.array([-1], numpy.int64),
op_version=target_opset,
output_names=['Y'])
onx = res.to_onnx(varsx,
outputs=[('Y', var_type([None]))],
target_opset=target_opset)
return onx
def _onnx_grad_penalty_elastic_error(target_opset=None,
dtype=numpy.float32,
l1_weight=0.01,
l2_weight=0.01):
"""
Returns the ONNX graph for function
:math:`Y = f(W) = \\beta \\lVert W \\rVert +
\\alpha \\lVert W \\rVert^2`
*l1_weight* is :math:`\\beta` and
*l2_weight* is :math:`\\alpha`.
.. gdot::
:script: DOT-SECTION
from mlprodict.onnxrt import OnnxInference
from onnxcustom.utils.onnx_function import function_onnx_graph
model_onnx = function_onnx_graph('grad_penalty_elastic_error')
oinf = OnnxInference(model_onnx, inplace=False)
print("DOT-SECTION", oinf.to_dot())
"""
from skl2onnx.algebra.onnx_ops import (OnnxMul, OnnxAdd,
OnnxReduceSumSquare, OnnxReduceSum,
OnnxSign, OnnxAbs, OnnxReshape)
diff = 'X'
abs_diff = OnnxAbs(diff, op_version=target_opset)
res_l1 = OnnxReduceSum(abs_diff, op_version=target_opset)
res2_l1 = OnnxSign(diff, op_version=target_opset)
res_l2 = OnnxReduceSumSquare(diff, op_version=target_opset)
res2_l2 = diff
res = OnnxAdd(OnnxMul(res_l1,
numpy.array([l1_weight], dtype=dtype),
op_version=target_opset),
OnnxMul(res_l2,
numpy.array([l2_weight], dtype=dtype),
op_version=target_opset),
op_version=target_opset)
res = OnnxReshape(res,
numpy.array([-1], numpy.int64),
op_version=target_opset,
output_names=['Y'])
res2 = OnnxAdd(OnnxMul(res2_l1,
numpy.array([l1_weight], dtype=dtype),
op_version=target_opset),
OnnxMul(res2_l2,
numpy.array([l2_weight * (2)], dtype=dtype),
op_version=target_opset),
op_version=target_opset,
output_names=['Y_grad'])
var_type = dtype_to_var_type(dtype)
varsx = [('X', var_type([None, None]))]
onx = res.to_onnx(varsx,
outputs=[('Y', var_type([None])),
('Y_grad', var_type())],
target_opset=target_opset,
other_outputs=[res2])
return onx