def dummy_converter(scope, operator, container):
X = operator.inputs[0]
out = operator.outputs
id1 = OnnxIdentity(X)
id2 = OnnxIdentity(id1, output_names=out[1:])
id2.add_to(scope, container)
def dummy_converter(scope, operator, container):
X = operator.inputs[0]
out = operator.outputs
id1 = OnnxIdentity(X, op_version=TARGET_OPSET)
id2 = OnnxIdentity(id1, output_names=out[1:], op_version=TARGET_OPSET)
id2.add_to(scope, container)
def decorrelate_transformer_convertor(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
X = operator.inputs[0]
subop = OnnxSubEstimator(op.pca_, X, op_version=opv)
Y = OnnxIdentity(subop, op_version=opv, output_names=out[:1])
Y.add_to(scope, container)
def custom_transformer_converter4(scope, operator, container):
i0 = operator.inputs[0]
outputs = operator.outputs
op = operator.raw_operator
opv = container.target_opset
out = OnnxSubEstimator(op.norm_, i0, op_version=opv)
final = OnnxIdentity(
out[1], output_names=outputs, op_version=opv)
final.add_to(scope, container)
def custom_linear_regressor_converter(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
X = operator.inputs[0]
dtype = guess_numpy_type(X.type)
m = OnnxAdd(OnnxMatMul(X, op.coef_.astype(dtype), op_version=opv),
numpy.array([op.intercept_]),
op_version=opv)
Y = OnnxIdentity(m, op_version=opv, output_names=out[:1])
Y.add_to(scope, container)
def decorrelate_transformer_converter2(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
X = operator.inputs[0]
dtype = guess_numpy_type(X.type)
m = OnnxMatMul(OnnxSub(X, op.pca_.mean_.astype(dtype), op_version=opv),
op.pca_.components_.T.astype(dtype),
op_version=opv)
Y = OnnxIdentity(m, op_version=opv, output_names=out[:1])
Y.add_to(scope, container)
def custom_cluster_converter(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
X = operator.inputs[0]
dtype = guess_numpy_type(X.type)
dist = OnnxMatMul(X, op.clusters_.astype(dtype), op_version=opv)
label = OnnxArgMax(dist, axis=1, op_version=opv)
Yl = OnnxIdentity(label, op_version=opv, output_names=out[:1])
Yp = OnnxIdentity(dist, op_version=opv, output_names=out[1:])
Yl.add_to(scope, container)
Yp.add_to(scope, container)
def subsub_mmtwo_converter(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
X = operator.inputs[0]
x2 = OnnxSubEstimator(op.est1_, X, op_version=opv)
x2.set_onnx_name_prefix('AAA')
x2_exp = OnnxExp(x2, op_version=opv)
x3 = OnnxSubEstimator(op.est2_, x2_exp, op_version=opv)
x3.set_onnx_name_prefix('BBB')
final = OnnxIdentity(x3, op_version=opv, output_names=out[:1])
final.add_to(scope, container)
def decorrelate_transformer_converter(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
# We retrieve the unique input.
X = operator.inputs[0]
# We tell in ONNX language how to compute the unique output.
# op_version=opv tells which opset is requested
subop = OnnxSubEstimator(op.pca_, X, op_version=opv)
Y = OnnxIdentity(subop, op_version=opv, output_names=out[:1])
Y.add_to(scope, container)
def custom_linear_classifier_converter(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
out = operator.outputs
X = operator.inputs[0]
dtype = guess_numpy_type(X.type)
raw = OnnxAdd(OnnxMatMul(X, op.coef_.astype(dtype), op_version=opv),
op.intercept_.astype(dtype),
op_version=opv)
prob = OnnxSigmoid(raw, op_version=opv)
label = OnnxArgMax(prob, axis=1, op_version=opv)
Yl = OnnxIdentity(label, op_version=opv, output_names=out[:1])
Yp = OnnxIdentity(prob, op_version=opv, output_names=out[1:])
Yl.add_to(scope, container)
Yp.add_to(scope, container)
def ordwoe_encoder_converter(scope, operator, container):
op = operator.raw_operator
opv = container.target_opset
X = operator.inputs[0]
sub = OnnxSubEstimator(op.encoder_, X, op_version=opv)
cast = OnnxCast(sub, op_version=opv, to=np.float32)
cat = OnnxSubEstimator(op.woe_,
cast,
op_version=opv,
input_types=[Int64TensorType()])
idcat = OnnxIdentity(cat,
output_names=operator.outputs[:1],
op_version=opv)
idcat.add_to(scope, container)
def validator_classifier_converter(scope, operator, container):
input = operator.inputs[0] # input in ONNX graph
outputs = operator.outputs # outputs in ONNX graph
op = operator.raw_operator # scikit-learn model (mmust be fitted)
opv = container.target_opset
# We reuse existing converter and declare it as local
# operator.
model = op.estimator_
onnx_op = OnnxSubEstimator(model, input, op_version=opv)
rmax = OnnxReduceMax(onnx_op[1], axes=[1], keepdims=0, op_version=opv)
great = OnnxGreater(rmax,
np.array([op.threshold], dtype=np.float32),
op_version=opv)
valid = OnnxCast(great, to=onnx_proto.TensorProto.INT64, op_version=opv)
r1 = OnnxIdentity(onnx_op[0],
output_names=[outputs[0].full_name],
op_version=opv)
r2 = OnnxIdentity(onnx_op[1],
output_names=[outputs[1].full_name],
op_version=opv)
r3 = OnnxIdentity(valid,
output_names=[outputs[2].full_name],
op_version=opv)
r1.add_to(scope, container)
r2.add_to(scope, container)
r3.add_to(scope, container)
def validator_classifier_converter(scope, operator, container):
input0 = operator.inputs[0] # first input in ONNX graph
outputs = operator.outputs # outputs in ONNX graph
op = operator.raw_operator # scikit-learn model (mmust be fitted)
opv = container.target_opset
# The model calls another one. The class `OnnxSubEstimator`
# calls the converter for this operator.
model = op.estimator_
onnx_op = OnnxSubEstimator(model,
input0,
op_version=opv,
options={'zipmap': False})
rmax = OnnxReduceMax(onnx_op[1], axes=[1], keepdims=0, op_version=opv)
great = OnnxGreater(rmax,
np.array([op.threshold], dtype=np.float32),
op_version=opv)
valid = OnnxCast(great, to=onnx_proto.TensorProto.INT64, op_version=opv)
r1 = OnnxIdentity(onnx_op[0],
output_names=[outputs[0].full_name],
op_version=opv)
r2 = OnnxIdentity(onnx_op[1],
output_names=[outputs[1].full_name],
op_version=opv)
r3 = OnnxIdentity(valid,
output_names=[outputs[2].full_name],
op_version=opv)
r1.add_to(scope, container)
r2.add_to(scope, container)
r3.add_to(scope, container)
def _common_converter_int_t(scope, operator, container):
if not hasattr(operator, 'onnx_numpy_fct_'):
raise AttributeError("operator must have attribute 'onnx_numpy_fct_'.")
X = operator.inputs
if len(X) != 1:
raise RuntimeError("This function only supports one input not %r." %
len(X))
if len(operator.outputs) != 2:
raise RuntimeError("This function only supports two outputs not %r." %
len(operator.outputs))
from skl2onnx.algebra.onnx_ops import OnnxIdentity # pylint: disable=E0611
from .onnx_variable import OnnxVar, TupleOnnxAny
xvar = OnnxVar(X[0])
fct_cl = operator.onnx_numpy_fct_
opv = container.target_opset
inst = fct_cl.fct(xvar, op_=operator.raw_operator)
onx = inst.to_algebra(op_version=opv)
if isinstance(onx, TupleOnnxAny):
if len(operator.outputs) != len(onx):
raise RuntimeError( # pragma: no cover
"Mismatched number of outputs expected %d, got %d." %
(len(operator.outputs), len(onx)))
for out, ox in zip(operator.outputs, onx):
if not hasattr(ox, 'add_to'):
raise TypeError( # pragma: no cover
"Unexpected type for onnx graph %r, inst=%r." %
(type(ox), type(inst)))
final = OnnxIdentity(ox,
op_version=opv,
output_names=[out.full_name])
final.add_to(scope, container)
else:
final = OnnxIdentity(onx,
op_version=opv,
output_names=[operator.outputs[0].full_name])
final.add_to(scope, container)
def _common_converter_t(scope, operator, container):
if not hasattr(operator, 'onnx_numpy_fct_'):
raise AttributeError("operator must have attribute 'onnx_numpy_fct_'.")
X = operator.inputs
if len(X) != 1:
raise RuntimeError("This function only supports one input not %r." %
len(X))
if len(operator.outputs) != 1:
raise RuntimeError("This function only supports one output not %r." %
len(operator.outputs))
from skl2onnx.algebra.onnx_ops import OnnxIdentity # pylint: disable=E0611
from .onnx_variable import OnnxVar
xvar = OnnxVar(X[0])
fct_cl = operator.onnx_numpy_fct_
opv = container.target_opset
inst = fct_cl.fct(xvar, op_=operator.raw_operator)
onx = inst.to_algebra(op_version=opv)
final = OnnxIdentity(onx,
op_version=opv,
output_names=[operator.outputs[0].full_name])
final.add_to(scope, container)
