def test_onnx_rename_names_type(self):
rows = []
def flog(*s):
rows.append(" ".join(map(str, s)))
dtype = numpy.float32
x = numpy.array([1, 2, 4, 5, 5, 4]).astype(numpy.float32).reshape(
(3, 2))
cop = OnnxAdd('X',
numpy.array([1], dtype=dtype),
op_version=TARGET_OPSET)
cop2 = OnnxAdd('X',
numpy.array([1], dtype=dtype),
op_version=TARGET_OPSET)
cop3 = OnnxAdd('X',
numpy.array([2], dtype=dtype),
op_version=TARGET_OPSET,
output_names=['inter'])
cop4 = OnnxSub(OnnxMul(cop, cop3, op_version=TARGET_OPSET),
cop2,
output_names=['final'],
op_version=TARGET_OPSET)
model_def = cop4.to_onnx({'X': x})
oinf1 = OnnxInference(model_def)
new_model = onnx_rename_names(model_def,
verbose=1,
fLOG=flog,
strategy='type')
total = "\n".join(rows)
self.assertIn("'Ad_Addcst' -> 'i_05'", total)
oinf2 = OnnxInference(new_model)
y1 = oinf1.run({'X': x})
y2 = oinf2.run({'X': x})
self.assertEqualArray(y1['final'], y2['final'])
def test_onnxt_runtime_empty(self):
idi = numpy.identity(2, dtype=numpy.float32)
onx = OnnxAdd('X', idi, output_names=['Y'], op_version=TARGET_OPSET)
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf = OnnxInference(model_def, runtime='empty')
self.assertNotEmpty(oinf)
def test_onnxview(self):
idi = numpy.identity(2)
onx = OnnxAdd('X',
idi,
output_names=['Y'],
op_version=get_opset_number_from_onnx())
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
mg = OnnxNotebook()
mg.add_context({"model": model_def})
cmd = "--help"
res, out, _ = self.capture(lambda: mg.onnxview(cmd))
self.assertEmpty(res)
self.assertIn("notebook", out)
mg = OnnxNotebook()
mg.add_context({"model": model_def})
cmd = "model"
res = mg.onnxview(cmd)
self.assertNotEmpty(res)
self.assertIn('RenderJsDot', str(res))
mg = OnnxNotebook()
mg.add_context({"model": model_def})
cmd = "-r 1 model"
res = mg.onnxview(cmd)
self.assertNotEmpty(res)
self.assertIn('RenderJsDot', str(res))
def test_onnxt_idi(self):
idi = numpy.identity(2)
onx = OnnxAdd('X', idi, output_names=['Y'])
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
oinf = OnnxInference(model_def)
res = str(oinf)
self.assertIn('op_type: "Add"', res)
sb = model_def.SerializeToString()
oinf = OnnxInference(sb)
res = str(oinf)
self.assertIn('op_type: "Add"', res)
sb = BytesIO(model_def.SerializeToString())
oinf = OnnxInference(sb)
res = str(oinf)
self.assertIn('op_type: "Add"', res)
temp = get_temp_folder(__file__, "temp_onnxrt_idi")
name = os.path.join(temp, "m.onnx")
with open(name, "wb") as f:
f.write(model_def.SerializeToString())
oinf = OnnxInference(name)
res = str(oinf)
self.assertIn('op_type: "Add"', res)
def test_complex(self):
for dt, var, pr in ((np.complex64, Complex64TensorType, 14),
(np.complex128, Complex128TensorType, 15)):
X = np.array([[1 - 2j, -12j], [-1 - 2j, 1 + 2j]]).astype(dt)
for opv in (10, 11, 12, 13, TARGET_OPSET):
if opv > TARGET_OPSET:
continue
out = OnnxAdd('X',
np.array([1 + 2j]),
output_names=['Y'],
op_version=opv)
onx = out.to_onnx([('X', var((None, 2)))],
outputs=[('Y', var())],
target_opset=opv)
self.assertIn('elem_type: %d' % pr, str(onx))
try:
ort = InferenceSession(onx.SerializeToString())
except InvalidGraph as e:
if "Type Error: Type 'tensor(complex" in str(e):
continue
raise e
assert ort is not None
got = ort.run(None, {'X': X})[0]
assert_almost_equal(X + np.array([1 + 2j]), got)
def test_onnx_init_sparse_coo(self):
row = np.array([0, 0, 1, 3, 1], dtype=np.float32)
col = np.array([0, 2, 1, 3, 1], dtype=np.float32)
data = np.array([1, 1, 1, 1, 1], dtype=np.float32)
X = coo_matrix((data, (row, col)), shape=(4, 4))
node = OnnxAdd(
'X', X, output_names=['Y'],
op_version=TARGET_OPSET)
model_def = node.to_onnx(
{'X': X}, outputs=[('Y', FloatTensorType())])
try:
sess = InferenceSession(model_def.SerializeToString())
except (RuntimeError, OrtInvalidArgument):
# Sparse tensor is not supported for constant.
return
try:
res = sess.run(None, {'X': X})[0]
except RuntimeError as e:
# Sparse tensor is not supported for constant.
warnings.warn(
"Unable to run with %r\n---\n%s\n%s" % (
{'X': X}, model_def, e))
return
assert_almost_equal(X + X, res)
def _onnx_linear_regression(target_opset=None, dtype=numpy.float32):
"""
Returns the ONNX graph for function
:math:`Y = f(X, A, B) = A X + B`.
.. gdot::
:script: DOT-SECTION
from mlprodict.onnxrt import OnnxInference
from onnxcustom.utils.onnx_function import function_onnx_graph
model_onnx = function_onnx_graph('linear_regression')
oinf = OnnxInference(model_onnx, inplace=False)
print("DOT-SECTION", oinf.to_dot())
"""
from skl2onnx.algebra.onnx_ops import (OnnxMatMul, OnnxAdd)
res = OnnxAdd(OnnxMatMul('X', 'A', op_version=target_opset),
'B',
op_version=target_opset,
output_names=['Y'])
var_type = dtype_to_var_type(dtype)
varsx = [('X', var_type([None, None])), ('A', var_type([None, None])),
('B', var_type([None, None]))]
onx = res.to_onnx(varsx,
outputs=[('Y', var_type())],
target_opset=target_opset,
other_outputs=[res])
return onx
def test_onnx_example_cdist_in(self):
x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
x2 = np.array([1.1, 2.1, 4.01, 5.01, 5.001, 4.001, 0,
0]).astype(np.float32).reshape((4, 2))
cop = OnnxAdd('input', 'input')
cop2 = OnnxIdentity(onnx_cdist(cop, x2, dtype=np.float32),
output_names=['cdist'])
model_def = cop2.to_onnx(inputs=[('input',
FloatTensorType([None, None]))],
outputs=[('cdist', FloatTensorType())])
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'input': x})
exp = scipy_cdist(x * 2, x2, metric="sqeuclidean")
assert_almost_equal(exp, res[0], decimal=5)
x = np.array(
[[6.1, 2.8, 4.7, 1.2], [5.7, 3.8, 1.7, 0.3], [7.7, 2.6, 6.9, 2.3],
[6.0, 2.9, 4.5, 1.5], [6.8, 2.8, 4.8, 1.4], [5.4, 3.4, 1.5, 0.4],
[5.6, 2.9, 3.6, 1.3], [6.9, 3.1, 5.1, 2.3]],
dtype=np.float32)
cop = OnnxAdd('input', 'input')
cop2 = OnnxIdentity(onnx_cdist(cop, x, dtype=np.float32),
output_names=['cdist'])
model_def = cop2.to_onnx(inputs=[('input',
FloatTensorType([None, None]))],
outputs=[('cdist', FloatTensorType())])
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'input': x})
exp = scipy_cdist(x * 2, x, metric="sqeuclidean")
assert_almost_equal(exp, res[0], decimal=4)
def test_onnx_if_algebra_indirect_unnamed_clear_input(self):
opv = TARGET_OPSET
x1 = np.array([[0, 3], [7, 0]], dtype=np.float32)
x2 = np.array([[1, 0], [2, 0]], dtype=np.float32)
node_xy = OnnxMul('x1', 'x2', op_version=opv)
node_then = OnnxAdd(
'x1', 'xy', output_names=['absxythen'], op_version=opv)
then_body = node_then.to_onnx(
{'x1': x1, 'xy': x2}, target_opset=opv,
outputs=[('absxythen', FloatTensorType())])
node_else = OnnxSub(
'x1', 'x2', output_names=['absxyelse'], op_version=opv)
else_body = node_else.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('absxyelse', FloatTensorType())])
cond = OnnxGreater(
OnnxReduceSum('x1', op_version=opv),
OnnxReduceSum('x2', op_version=opv),
op_version=opv)
ifnode = OnnxIf(cond, then_branch=then_body.graph,
else_branch=else_body.graph,
op_version=opv, output_names=['y'],
global_context={'xy': node_xy},
clear_subgraph_inputs=True)
model_def = ifnode.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('y', FloatTensorType())])
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'x1': x1, 'x2': x2})
assert_almost_equal(x1 + x1 * x2, res[0])
def test_onnx_subgraphs2(self):
x = numpy.array([1, 2, 4, 5, 5, 4]).astype(numpy.float32).reshape(
(3, 2))
cop = OnnxAdd(OnnxIdentity('input', op_version=TARGET_OPSET),
'input',
op_version=TARGET_OPSET)
cdist = onnx_squareform_pdist(cop,
dtype=numpy.float32,
op_version=TARGET_OPSET)
id1 = [id(a) for a in cdist.onx_op.graph_algebra['body']]
cdist2 = onnx_squareform_pdist(cop,
dtype=numpy.float32,
op_version=TARGET_OPSET)
id2 = [id(a) for a in cdist2.onx_op.graph_algebra['body']]
self.assertNotEqual(id1, id2)
cop2 = OnnxAdd(cdist,
cdist2,
output_names=['cdist'],
op_version=TARGET_OPSET)
model_def = cop2.to_onnx({'input': FloatTensorType([None, None])},
outputs=[('cdist',
FloatTensorType([None, None]))],
target_opset=TARGET_OPSET)
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'input': x})
self.assertEqual(len(res), 1)
def _onnx_axpy(target_opset=None, dtype=numpy.float32):
"""
Returns the ONNX graph for function
:math:`Y = f(X1, X2, \\alpha) = \\alpha X1 + X2`.
.. gdot::
:script: DOT-SECTION
from mlprodict.onnxrt import OnnxInference
from onnxcustom.utils.onnx_function import function_onnx_graph
model_onnx = function_onnx_graph('axpy')
oinf = OnnxInference(model_onnx, inplace=False)
print("DOT-SECTION", oinf.to_dot())
"""
from skl2onnx.algebra.onnx_ops import OnnxAdd, OnnxMul
res = OnnxAdd(OnnxMul('X1', 'alpha', op_version=target_opset),
'X2',
op_version=target_opset,
output_names=['Y'])
var_type = dtype_to_var_type(dtype)
varsx = [('X1', var_type()), ('X2', var_type()), ('alpha', var_type([1]))]
onx = res.to_onnx(varsx,
outputs=[('Y', var_type())],
target_opset=target_opset)
return onx
def _onnx_axpyw2(target_opset=None, dtype=numpy.float32):
"""
Returns the ONNX graph for function
:math:`Y, Z = f(X1, X2, G, \\alpha, \\beta) = (Y, Z)`
where :math:`Z = \\beta G + \\alpha X1` and
:math:`Y = \\beta * Z + \\alpha X1 + X2`.
.. gdot::
:script: DOT-SECTION
from mlprodict.onnxrt import OnnxInference
from onnxcustom.utils.onnx_function import function_onnx_graph
model_onnx = function_onnx_graph('axpy')
oinf = OnnxInference(model_onnx, inplace=False)
print("DOT-SECTION", oinf.to_dot())
"""
from skl2onnx.algebra.onnx_ops import OnnxAdd, OnnxMul
s1 = OnnxMul('X1', 'alpha', op_version=target_opset)
s2 = OnnxMul('G', 'beta', op_version=target_opset)
Z = OnnxAdd(s1, s2, op_version=target_opset, output_names=['Z'])
s2_2 = OnnxMul(Z, 'beta', op_version=target_opset)
s2_3 = OnnxAdd(s1, s2_2, op_version=target_opset)
Y = OnnxAdd(s2_3, 'X2', op_version=target_opset, output_names=['Y'])
var_type = dtype_to_var_type(dtype)
varsx = [('X1', var_type()), ('X2', var_type()), ('G', var_type()),
('alpha', var_type([1])), ('beta', var_type([1]))]
onx = Y.to_onnx(varsx,
outputs=[('Y', var_type()), ('Z', var_type())],
target_opset=target_opset,
other_outputs=[Z])
return onx
def test_onnx_if_algebra_direct(self):
opv = TARGET_OPSET
x1 = np.array([[0, 3], [7, 0]], dtype=np.float32)
x2 = np.array([[1, 0], [2, 0]], dtype=np.float32)
node = OnnxAdd(
'x1', 'x2', output_names=['absxythen'], op_version=opv)
then_body = node.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('absxythen', FloatTensorType())])
node = OnnxSub(
'x1', 'x2', output_names=['absxyelse'], op_version=opv)
else_body = node.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('absxyelse', FloatTensorType())])
del else_body.graph.input[:]
del then_body.graph.input[:]
cond = OnnxGreater(
OnnxReduceSum('x1', op_version=opv),
OnnxReduceSum('x2', op_version=opv),
op_version=opv)
ifnode = OnnxIf(cond, then_branch=then_body.graph,
else_branch=else_body.graph,
op_version=opv, output_names=['y'])
model_def = ifnode.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('y', FloatTensorType())])
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'x1': x1, 'x2': x2})
assert_almost_equal(x1 + x2, res[0])
def test_pipeline_add(self):
iris = load_iris()
X, y = iris.data, iris.target
pca = PCA(n_components=2)
pca.fit(X)
add = OnnxAdd('X',
numpy.full((1, X.shape[1]), 1, dtype=numpy.float32),
output_names=['Yadd'])
onx = add.to_onnx(inputs=[('X', FloatTensorType((None, X.shape[1])))],
outputs=[('Yadd', FloatTensorType(
(None, X.shape[1])))])
tr = OnnxTransformer(onx)
tr.fit()
pipe = make_pipeline(tr, LogisticRegression())
pipe.fit(X, y)
pred = pipe.predict(X)
self.assertEqual(pred.shape, (150, ))
model_onnx = to_onnx(pipe, X.astype(numpy.float32))
oinf = OnnxInference(model_onnx)
y1 = pipe.predict(X)
y2 = oinf.run({'X': X.astype(numpy.float32)})
self.assertEqual(list(y2), ['output_label', 'output_probability'])
self.assertEqualArray(y1, y2['output_label'])
y1 = pipe.predict_proba(X)
probas = DataFrame(list(y2['output_probability'])).values
self.assertEqualArray(y1, probas, decimal=5)
def test_onnxt_runtime_add_raise(self):
idi = numpy.identity(2).astype(numpy.float32)
onx = OnnxAdd('X', idi, output_names=['Y2'],
op_version=TARGET_OPSET)
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
self.assertRaise(lambda: OnnxInference(model_def, runtime='onnxruntime-1'),
ValueError)
def test_onnx_remove_redundant_subgraphs_full(self):
from skl2onnx.algebra.complex_functions import onnx_squareform_pdist
cop = OnnxAdd(OnnxIdentity('input',
op_version=get_opset_number_from_onnx()),
'input',
op_version=get_opset_number_from_onnx())
cdist = onnx_squareform_pdist(cop,
dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
cdist2 = onnx_squareform_pdist(cop,
dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
cop2 = OnnxAdd(cdist,
cdist2,
output_names=['cdist'],
op_version=get_opset_number_from_onnx())
model_def = cop2.to_onnx({'input': FloatTensorType()},
outputs=[('cdist', FloatTensorType())],
target_opset=get_opset_number_from_onnx())
stats = onnx_statistics(model_def, optim=False)
new_model = onnx_optimisations(model_def)
stats2 = onnx_statistics(new_model, optim=False)
self.assertLess(stats2['size'], stats['size'])
self.assertLess(stats2['nnodes'], stats['nnodes'])
self.assertLess(stats2['op_Identity'], stats['op_Identity'])
def test_onnxt_reduce_size(self):
idi = numpy.identity(2)
onx = OnnxAdd('X', idi, output_names=['Y'],
op_version=get_opset_number_from_onnx())
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
oinf = OnnxInference(model_def, runtime="python_compiled")
res = oinf.run({'X': idi.astype(numpy.float32)})
self.assertEqual(idi * 2, res['Y'])
oinf.reduce_size(False)
res = oinf.run({'X': idi.astype(numpy.float32)})
self.assertEqual(idi * 2, res['Y'])
st = BytesIO()
try:
pickle.dump(oinf, st)
except AttributeError:
# missing obj
pass
oinf = OnnxInference(model_def, runtime="python_compiled")
res = oinf.run({'X': idi.astype(numpy.float32)})
self.assertEqual(idi * 2, res['Y'])
oinf.reduce_size(True)
res = oinf.run({'X': idi.astype(numpy.float32)})
self.assertEqual(idi * 2, res['Y'])
st = BytesIO()
pickle.dump(oinf, st)
val = st.getvalue()
oinf2 = pickle.load(BytesIO(val))
self.assertNotEmpty(oinf2)
def test_if2(self):
opv = TARGET_OPSET
x1 = numpy.array([[0, 3], [7, 0]], dtype=numpy.float32)
x2 = numpy.array([[1, 0], [2, 0]], dtype=numpy.float32)
node = OnnxAdd(
'x1', 'x2', output_names=['absxythen'], op_version=opv)
then_body = node.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('absxythen', FloatTensorType())])
node = OnnxSub(
'x1', 'x2', output_names=['absxyelse'], op_version=opv)
else_body = node.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('absxyelse', FloatTensorType())])
del else_body.graph.input[:]
del then_body.graph.input[:]
cond = OnnxGreater(
OnnxReduceSum('x1', op_version=opv),
OnnxReduceSum('x2', op_version=opv),
op_version=opv)
ifnode = OnnxIf(cond, then_branch=then_body.graph,
else_branch=else_body.graph,
op_version=opv, output_names=['y'])
model_def = ifnode.to_onnx(
{'x1': x1, 'x2': x2}, target_opset=opv,
outputs=[('y', FloatTensorType())])
oinf = OnnxInference(model_def)
dot = oinf.to_dot()
self.assertIn("Gr_Greater -> Gr_C0;", dot)
def test_onnxt_add(self):
idi = numpy.identity(2)
onx = OnnxAdd('X', idi, output_names=['Y'])
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
oinf = OnnxInference(model_def, runtime="python")
res = oinf.switch_initializers_dtype()
self.assertEqual(len(res), 1)
self.assertEqual(res[0][:4], ('pass1', '+', 'init', 'Ad_Addcst'))
def test_onnxt_json(self):
idi = numpy.identity(2)
idi2 = numpy.identity(2) * 2
onx = OnnxAdd(OnnxAdd('X', idi), idi2, output_names=['Y'])
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
oinf = OnnxInference(model_def)
js = oinf.to_json()
self.assertIn('"initializers": {', js)
def test_onnxt_runtime_add(self):
idi = numpy.identity(2)
onx = OnnxAdd('X', idi, output_names=['Y'])
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
X = numpy.array([[1, 2], [3, 4]], dtype=numpy.float32)
oinf = OnnxInference(model_def, runtime='onnxruntime2')
got = oinf.run({'X': X})
self.assertEqual(list(sorted(got)), ['Y'])
self.assertEqualArray(idi + X, got['Y'], decimal=6)
def pyod_iforest_converter(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
# We retrieve the unique input.
X = operator.inputs[0]
# In most case, computation happen in floats.
# But it might be with double. ONNX is very strict
# about types, every constant should have the same
# type as the input.
dtype = guess_numpy_type(X.type)
detector = op.detector_ # Should be IForest from scikit-learn.
lab_pred = OnnxSubEstimator(detector, X, op_version=opv)
scores = OnnxIdentity(lab_pred[1], op_version=opv)
# labels
threshold = op.threshold_
above = OnnxLess(scores,
np.array([threshold], dtype=dtype),
op_version=opv)
labels = OnnxCast(above,
op_version=opv,
to=onnx_proto.TensorProto.INT64,
output_names=out[:1])
# probabilities
train_scores = op.decision_scores_
scaler = MinMaxScaler().fit(train_scores.reshape(-1, 1))
scores_ = OnnxMul(scores, np.array([-1], dtype=dtype), op_version=opv)
print(scaler.min_)
print(scaler.scale_)
scaled = OnnxMul(scores_, scaler.scale_.astype(dtype), op_version=opv)
scaled_centered = OnnxAdd(scaled,
scaler.min_.astype(dtype),
op_version=opv)
clipped = OnnxClip(scaled_centered,
np.array([0], dtype=dtype),
np.array([1], dtype=dtype),
op_version=opv)
clipped_ = OnnxAdd(OnnxMul(clipped,
np.array([-1], dtype=dtype),
op_version=opv),
np.array([1], dtype=dtype),
op_version=opv)
scores_2d = OnnxConcat(clipped_,
clipped,
axis=1,
op_version=opv,
output_names=out[1:])
labels.add_to(scope, container)
scores_2d.add_to(scope, container)
def build_ort_add(op_version=12):
node1 = OnnxAdd('x', 'y', op_version=op_version)
node2 = OnnxAdd(node1, 'y', op_version=op_version)
node = OnnxAdd(node2, 'y', op_version=op_version, output_names=['z'])
onx = node.to_onnx(inputs=[('x', FloatTensorType()),
('y', FloatTensorType())],
target_opset=op_version)
sess = InferenceSession(onx.SerializeToString())
return lambda x, y: sess.run(None, {'x': x, 'y': y})
def test_onnxt_run(self):
idi = numpy.identity(2)
idi2 = numpy.identity(2) * 2
onx = OnnxAdd(OnnxAdd('X', idi), idi2, output_names=['Y'])
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
oinf = OnnxInference(model_def)
X = numpy.array([[1, 1], [3, 3]])
y = oinf.run({'X': X.astype(numpy.float32)})
exp = numpy.array([[4, 1], [3, 6]], dtype=numpy.float32)
self.assertEqual(list(y), ['Y'])
self.assertEqualArray(y['Y'], exp)
def test_code_add_except(self):
idi = numpy.identity(2, dtype=numpy.float32)
onx = OnnxAdd('X', idi, output_names=['Y'], op_version=TARGET_OPSET)
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)},
target_opset=TARGET_OPSET)
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf = OnnxInference(model_def, runtime='onnxruntime1')
try:
oinf.to_python()
except ValueError:
pass
def test_grad_helper_exc(self):
opv = opset
node = OnnxAdd('X',
numpy.array([1], dtype=numpy.float32),
op_version=opv,
output_names=['Y'])
onx = node.to_onnx({'X': FloatTensorType([None, 10])},
{'Y': FloatTensorType([None, 10])},
target_opset=opv)
self.assertRaise(lambda: onnx_derivative(onx, weights=[], options=1),
TypeError)
def test_grad_helper_noweight(self):
opv = opset
node = OnnxAdd('X',
numpy.array([1], dtype=numpy.float32),
op_version=opv,
output_names=['Y'])
onx = node.to_onnx({'X': FloatTensorType([None, 10])},
{'Y': FloatTensorType([None, 10])},
target_opset=opv)
new_onx = onnx_derivative(onx, weights=[])
self.check_runtime(new_onx, 'test_grad_helper_noweight')
def generate_onnx_graph(dim, nbnode, input_name='X1'):
i1 = input_name
for i in range(nbnode - 1):
i2 = (np.ones((1, dim)) * nbnode * 10).astype(np.float32)
node = OnnxAdd(i1, i2)
i1 = node
i2 = (np.ones((1, dim)) * nbnode * 10).astype(np.float32)
node = OnnxAdd(i1, i2, output_names=['Y'])
onx = node.to_onnx([(input_name, FloatTensorType((None, dim)))],
outputs=[('Y', FloatTensorType())])
return onx
def test_onnx_init_dense(self):
X = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2))
node = OnnxAdd('X', X, output_names=['Y'], op_version=TARGET_OPSET)
model_def = node.to_onnx({'X': X}, outputs=[('Y', FloatTensorType())])
sess = InferenceSession(model_def.SerializeToString())
res = sess.run(None, {'X': X})[0]
assert_almost_equal(X + X, res)
def test_add(self):
idi = numpy.identity(2)
onx = OnnxAdd('X', idi, output_names=['Y'])
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)},
target_opset=12)
X = numpy.array([[1, 2], [3, 4]], dtype=numpy.float32)
sess = InferenceSession(model_def.SerializeToString())
got = sess.run(None, {'X': X})
exp = idi + X
self.assertEqual(exp.shape, got[0].shape)
self.assertEqual(list(exp.ravel()), list(got[0].ravel()))
self.assertIn("version: 7", str(model_def))
