def __init__(self, onnx_data, runtime):
"""
@param onnx_data :epkg:`ONNX` model or data
@param runtime runtime to be used,
mostly :epkg:`onnxruntime`
"""
if runtime != 'onnxruntime1':
raise NotImplementedError(
"runtime '{}' is not implemented.".format(runtime))
if hasattr(onnx_data, 'SerializeToString'):
onnx_data = onnx_data.SerializeToString()
self.runtime = runtime
sess_options = SessionOptions()
self.run_options = RunOptions()
try:
sess_options.session_log_severity_level = 3
# sess_options.sessions_log_verbosity_level = 0
except AttributeError: # pragma: no cover
# onnxruntime not recent enough.
pass
try:
self.run_options.run_log_severity_level = 3
# self.run_options.run_log_verbosity_level = 0
except AttributeError: # pragma: no cover
# onnxruntime not recent enough.
pass
self.sess = InferenceSession(onnx_data, sess_options=sess_options)
def _init(self, variables=None):
"""
Initializes the node.
@param variables registered variables created by previous operators
The current implementation for operator *Scan*
only works for matrices.
"""
try:
self.alg_class = getattr(alg2, 'Onnx' + self.onnx_node.op_type)
except AttributeError:
self.alg_class = getattr(alg, 'Onnx' + self.onnx_node.op_type)
inputs = list(self.onnx_node.input)
self.mapping, self.inputs = self._name_mapping(inputs)
self.outputs = list(self.onnx_node.output)
options = self.options.copy()
target_opset = options.pop('target_opset', None)
domain = options.pop('domain', None)
disable_optimisation = options.pop('disable_optimisation', False)
ir_version = options.pop('ir_version', None)
if domain == '' and target_opset < 9:
# target_opset should be >= 9 not {} for main domain.
# We assume it was the case when the graph was created.
pass
if self.onnx_node.op_type == 'ConstantOfShape':
for k in options:
v = options[k]
if isinstance(v, numpy.ndarray):
options[k] = make_tensor(k,
self._guess_proto_type(v.dtype),
v.shape, v.tolist())
self.inst_ = self.alg_class(*self.inputs,
output_names=self.outputs,
op_version=target_opset,
**options)
inputs = get_defined_inputs(self.inputs,
variables,
dtype=self.dtype)
try:
self.onnx_ = self.inst_.to_onnx(inputs,
target_opset=target_opset,
domain=domain)
if "dim_value: 0" in str(self.onnx_):
raise RuntimeError( # pragma: no cover
"Probable issue as one dimension is null.\n--\n{}".
format(self.onnx_))
except AttributeError as e: # pragma: no cover
# older version of skl2onnx
self.onnx_ = self.inst_.to_onnx(inputs)
if "dim_value: 0" in str(self.onnx_):
raise RuntimeError(
"Probable issue as one dimension is null.\n--\n{}".
format(self.onnx_)) from e
forced = False
elif self.onnx_node.op_type == 'Scan':
self.inst_ = self.alg_class(*self.inputs,
output_names=self.outputs,
op_version=target_opset,
**options)
inputs = get_defined_inputs(self.inputs,
variables,
dtype=self.dtype)
outputs = get_defined_outputs(self.outputs,
self.onnx_node,
inputs,
variables,
dtype=self.dtype)
inputs = [(name, cl.__class__([None, None]))
for (name, cl) in inputs]
outputs = [(name, cl.__class__([None, None]))
for (name, cl) in outputs]
self.onnx_ = self.inst_.to_onnx(inputs,
outputs=outputs,
target_opset=target_opset,
domain=domain)
if "dim_value: 0" in str(self.onnx_):
raise RuntimeError( # pragma: no cover
"Probable issue as one dimension is null.\n--\n{}".format(
self.onnx_))
forced = True
else:
self.inst_ = self.alg_class(*self.inputs,
output_names=self.outputs,
op_version=target_opset,
domain=domain,
**options)
inputs = get_defined_inputs(self.inputs,
variables,
dtype=self.dtype)
try:
self.onnx_ = self.inst_.to_onnx(inputs,
target_opset=target_opset,
domain=domain)
if "dim_value: 0" in str(self.onnx_):
raise RuntimeError( # pragma: no cover
"Probable issue as one dimension is null.\n--\n{}\n---\n{}"
.format(self.onnx_, inputs))
forced = False
except (RuntimeError, ValueError):
# Let's try again by forcing output types.
forced = True
outputs = get_defined_outputs(self.outputs,
self.onnx_node,
inputs,
variables,
dtype=self.dtype)
self.onnx_ = self.inst_.to_onnx(inputs,
outputs=outputs,
target_opset=target_opset,
domain=domain)
if "dim_value: 0" in str(self.onnx_):
raise RuntimeError( # pragma: no cover
"Probable issue as one dimension is null.\n--\n{}".
format(self.onnx_)) from e
if len(self.onnx_.graph.output) != len(self.outputs):
# Something is wrong, falls back to default plan.
forced = True
outputs = get_defined_outputs(self.outputs,
self.onnx_node,
inputs,
variables,
dtype=self.dtype)
self.onnx_ = self.inst_.to_onnx(inputs,
outputs=outputs,
target_opset=target_opset,
domain=domain)
if "dim_value: 0" in str(self.onnx_):
raise RuntimeError(
"Probable issue as one dimension is null.\n--\n{}".format(
self.onnx_))
else:
lo = list(self.onnx_.graph.output)
outputs = proto2vars(lo)
sess_options = SessionOptions()
self.run_options = RunOptions()
try:
sess_options.session_log_severity_level = 3
# sess_options.sessions_log_verbosity_level = 0
except AttributeError:
# onnxruntime not recent enough.
pass
try:
self.run_options.run_log_severity_level = 3
# self.run_options.run_log_verbosity_level = 0
except AttributeError:
# onnxruntime not recent enough.
pass
if ir_version is not None:
self.onnx_.ir_version = ir_version
if disable_optimisation:
sess_options.graph_optimization_level = (
GraphOptimizationLevel.ORT_DISABLE_ALL)
try:
self.sess_ = InferenceSession(self.onnx_.SerializeToString(),
sess_options=sess_options)
except (RuntimeError, OrtNotImplemented, OrtInvalidGraph,
OrtFail) as e:
raise RuntimeError(
"Unable to load node '{}' (output type was {})\n{}".format(
self.onnx_node.op_type,
"guessed" if forced else "inferred", self.onnx_)) from e
self.typed_outputs_ = outputs
def _init(self, variables=None):
"""
Initializes the node.
@param variables registered variables created by previous operators
The current implementation for operator *Scan*
only works for matrices.
"""
self.alg_class = getattr(alg, 'Onnx' + self.onnx_node.op_type)
inputs = list(self.onnx_node.input)
self.mapping, self.inputs = self._name_mapping(inputs)
self.outputs = list(self.onnx_node.output)
options = self.options.copy()
target_opset = options.pop('target_opset', None)
if self.onnx_node.op_type == 'ConstantOfShape':
for k in options:
v = options[k]
if isinstance(v, numpy.ndarray):
options[k] = make_tensor(k,
self._guess_proto_type(v.dtype),
v.shape, v.tolist())
self.inst_ = self.alg_class(*self.inputs,
output_names=self.outputs,
op_version=target_opset,
**options)
inputs = get_defined_inputs(self.inputs,
variables,
dtype=self.dtype)
self.onnx_ = self.inst_.to_onnx(inputs,
target_opset=target_opset,
dtype=self.dtype)
forced = False
elif self.onnx_node.op_type == 'Scan':
self.inst_ = self.alg_class(*self.inputs,
output_names=self.outputs,
op_version=target_opset,
**options)
inputs = get_defined_inputs(self.inputs,
variables,
dtype=self.dtype)
outputs = get_defined_outputs(self.outputs,
self.onnx_node,
inputs,
variables,
dtype=self.dtype)
inputs = [(name, cl.__class__([None, None]))
for (name, cl) in inputs]
outputs = [(name, cl.__class__([None, None]))
for (name, cl) in outputs]
self.onnx_ = self.inst_.to_onnx(inputs,
outputs=outputs,
target_opset=target_opset,
dtype=self.dtype)
forced = True
else:
self.inst_ = self.alg_class(*self.inputs,
output_names=self.outputs,
op_version=target_opset,
**options)
inputs = get_defined_inputs(self.inputs,
variables,
dtype=self.dtype)
try:
self.onnx_ = self.inst_.to_onnx(inputs,
target_opset=target_opset,
dtype=self.dtype)
forced = False
except (RuntimeError, ValueError):
# Let's try again by forcing output types.
forced = True
outputs = get_defined_outputs(self.outputs,
self.onnx_node,
inputs,
variables,
dtype=self.dtype)
self.onnx_ = self.inst_.to_onnx(inputs,
outputs=outputs,
target_opset=target_opset,
dtype=self.dtype)
if len(self.onnx_.graph.output) != self.outputs:
# Something is wrong, falls back to default plan.
forced = True
outputs = get_defined_outputs(self.outputs,
self.onnx_node,
inputs,
variables,
dtype=self.dtype)
self.onnx_ = self.inst_.to_onnx(inputs,
outputs=outputs,
target_opset=target_opset,
dtype=self.dtype)
sess_options = SessionOptions()
self.run_options = RunOptions()
try:
sess_options.session_log_severity_level = 3
# sess_options.sessions_log_verbosity_level = 0
except AttributeError:
# onnxruntime not recent enough.
pass
try:
self.run_options.run_log_severity_level = 3
# self.run_options.run_log_verbosity_level = 0
except AttributeError:
# onnxruntime not recent enough.
pass
try:
self.sess_ = InferenceSession(self.onnx_.SerializeToString(),
sess_options=sess_options)
except RuntimeError as e:
raise RuntimeError(
"Unable to load node '{}' (output type was {})\n{}".format(
self.onnx_node.op_type,
"guessed" if forced else "inferred", self.onnx_)) from e
self.typed_outputs_ = outputs
