def make_tensor(
name, # type: Text
data_type, # type: int
dims, # type: Sequence[int]
vals, # type: Any
raw=False # type: bool
): # type: (...) -> TensorProto
'''
Make a TensorProto with specified arguments. If raw is False, this
function will choose the corresponding proto field to store the
values based on data_type. If raw is True, use "raw_data" proto
field to store the values, and values should be of type bytes in
this case.
'''
tensor = TensorProto()
tensor.data_type = data_type
tensor.name = name
if data_type == TensorProto.STRING:
assert not raw, "Can not use raw_data to store string type"
if (data_type == TensorProto.COMPLEX64
or data_type == TensorProto.COMPLEX128):
vals = split_complex_to_pairs(vals)
if raw:
tensor.raw_data = vals
else:
field = mapping.STORAGE_TENSOR_TYPE_TO_FIELD[
mapping.TENSOR_TYPE_TO_STORAGE_TENSOR_TYPE[data_type]]
getattr(tensor, field).extend(vals)
tensor.dims.extend(dims)
return tensor
def from_array(
arr,
name=None): # type: (np.ndarray[Any], Optional[Text]) -> TensorProto
"""Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
"""
tensor = TensorProto()
tensor.dims.extend(arr.shape)
if name:
tensor.name = name
if arr.dtype == np.object:
# Special care for strings.
raise NotImplementedError("Need to properly implement string.")
# For numerical types, directly use numpy raw bytes.
try:
dtype = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
except KeyError:
raise RuntimeError("Numpy data type not understood yet: {}".format(
str(arr.dtype)))
tensor.data_type = dtype
tensor.raw_data = arr.tobytes() # note: tobytes() is only after 1.9.
return tensor
def from_array(arr, name=None): # type: (np.ndarray[Any], Optional[Text]) -> TensorProto
"""Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
"""
tensor = TensorProto()
tensor.dims.extend(arr.shape)
if name:
tensor.name = name
if arr.dtype == np.object:
# Special care for strings.
raise NotImplementedError("Need to properly implement string.")
# For numerical types, directly use numpy raw bytes.
try:
dtype = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
except KeyError:
raise RuntimeError(
"Numpy data type not understood yet: {}".format(str(arr.dtype)))
tensor.data_type = dtype
tensor.raw_data = arr.tobytes() # note: tobytes() is only after 1.9.
return tensor
def from_array(value, name=None):
"""
Converts an array into an ONNX tensor.
:param value: numpy array
:return: ONNX tensor
"""
if isinstance(value, numpy.ndarray):
try:
pb = onnx_from_array(value, name=name)
except NotImplementedError as e: # pragma: no cover
if value.dtype == numpy.dtype('O'):
pb = TensorProto()
pb.data_type = TensorProto.STRING # pylint: disable=E1101
if name is not None:
pb.name = name
pb.dims.extend(value.shape) # pylint: disable=E1101
pb.string_data.extend( # pylint: disable=E1101
list(map(lambda o: str(o).encode('utf-8'), value.ravel())))
else:
raise NotImplementedError(
"Unable to convert type %r (dtype=%r) into an ONNX tensor "
"due to %r." % (type(value), value.dtype, e)) from e
return pb
if isinstance(value, TensorProto): # pragma: no cover
return value
raise NotImplementedError( # pragma: no cover
"Unable to convert type %r into an ONNX tensor." % type(value))
def make_tensor(
name, # type: Text
data_type, # type: TensorProto.DataType
dims, # type: Sequence[int]
vals, # type: Any
raw=False # type: bool
): # type: (...) -> TensorProto
'''
Make a TensorProto with specified arguments. If raw is False, this
function will choose the corresponding proto field to store the
values based on data_type. If raw is True, use "raw_data" proto
field to store the values, and values should be of type bytes in
this case.
'''
tensor = TensorProto()
tensor.data_type = data_type
tensor.name = name
if data_type == TensorProto.STRING:
assert not raw, "Can not use raw_data to store string type"
if (data_type == TensorProto.COMPLEX64 or
data_type == TensorProto.COMPLEX128):
vals = split_complex_to_pairs(vals)
if raw:
tensor.raw_data = vals
else:
field = mapping.STORAGE_TENSOR_TYPE_TO_FIELD[
mapping.TENSOR_TYPE_TO_STORAGE_TENSOR_TYPE[data_type]]
getattr(tensor, field).extend(vals)
tensor.dims.extend(dims)
return tensor
def make_tensor(
name: Text,
data_type: int,
dims: Sequence[int],
vals: Any,
raw: bool = False
) -> TensorProto:
'''
Make a TensorProto with specified arguments. If raw is False, this
function will choose the corresponding proto field to store the
values based on data_type. If raw is True, use "raw_data" proto
field to store the values, and values should be of type bytes in
this case.
Arguments:
name (string): tensor name
data_type (int): a value such as onnx.TensorProto.FLOAT
dims (List[int]): shape
vals: values
raw (bool): if True, vals contains the seralized content of the tensor,
otherwise, vals should be a list of values of the type defined by *data_type*
Returns:
TensorProto
'''
tensor = TensorProto()
tensor.data_type = data_type
tensor.name = name
if data_type == TensorProto.STRING:
assert not raw, "Can not use raw_data to store string type"
# Check number of vals specified equals tensor size
expected_size = 1 if (not raw) else (mapping.TENSOR_TYPE_TO_NP_TYPE[data_type].itemsize)
# Flatten a numpy array if its rank > 1
if type(vals) is np.ndarray and len(vals.shape) > 1:
vals = vals.flatten()
for d in dims:
expected_size = expected_size * d
if len(vals) != expected_size:
raise ValueError("Number of values does not match tensor's size. Expected {}, but it is {}. "
.format(expected_size, len(vals)))
if raw:
tensor.raw_data = vals
else:
if (data_type == TensorProto.COMPLEX64
or data_type == TensorProto.COMPLEX128):
vals = split_complex_to_pairs(vals)
# floa16/bfloat16 are stored as uint16
elif (data_type == TensorProto.FLOAT16
or data_type == TensorProto.BFLOAT16):
vals = np.array(vals).astype(np.float16).view(dtype=np.uint16).flatten().tolist()
field = mapping.STORAGE_TENSOR_TYPE_TO_FIELD[
mapping.TENSOR_TYPE_TO_STORAGE_TENSOR_TYPE[data_type]]
getattr(tensor, field).extend(vals)
tensor.dims.extend(dims)
return tensor
def from_array(
arr,
name=None): # type: (np.ndarray[Any], Optional[Text]) -> TensorProto
"""Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
"""
tensor = TensorProto()
tensor.dims.extend(arr.shape)
if name:
tensor.name = name
if arr.dtype == object:
# Special care for strings.
tensor.data_type = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
# TODO: Introduce full string support.
# We flatten the array in case there are 2-D arrays are specified
# We throw the error below if we have a 3-D array or some kind of other
# object. If you want more complex shapes then follow the below instructions.
# Unlike other types where the shape is automatically inferred from
# nested arrays of values, the only reliable way now to feed strings
# is to put them into a flat array then specify type astype(object)
# (otherwise all strings may have different types depending on their length)
# and then specify shape .reshape([x, y, z])
flat_array = arr.flatten()
for e in flat_array:
if isinstance(e, text_type):
tensor.string_data.append(e.encode('utf-8'))
elif isinstance(e, np.ndarray):
for s in e:
if isinstance(s, text_type):
tensor.string_data.append(s.encode('utf-8'))
elif isinstance(s, bytes):
tensor.string_data.append(s)
elif isinstance(e, bytes):
tensor.string_data.append(e)
else:
raise NotImplementedError(
"Unrecognized object in the object array, expect a string, or array of bytes: ",
str(type(e)))
return tensor
# For numerical types, directly use numpy raw bytes.
try:
dtype = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
except KeyError:
raise RuntimeError("Numpy data type not understood yet: {}".format(
str(arr.dtype)))
tensor.data_type = dtype
tensor.raw_data = arr.tobytes() # note: tobytes() is only after 1.9.
if sys.byteorder == 'big':
# Convert endian from big to little
convert_endian(tensor)
return tensor
def make_external_tensor(name, data_type, dims, raw_data=None, **kwargs):
tensor = TensorProto()
tensor.data_type = data_type
tensor.name = name
tensor.dims.extend(dims)
if raw_data is not None:
tensor.raw_data = raw_data
external_data_helper.set_external_data(tensor, **kwargs)
order_repeated_field(tensor.external_data, 'key', kwargs.keys())
return tensor
def make_tensor(name: str, vals: np.ndarray) -> ITensorProto:
"""
Make a TensorProto with specified arguments. If raw is False, this
function will choose the corresponding proto field to store the
values based on data_type. If raw is True, use "raw_data" proto
field to store the values, and values should be of type bytes in
this case.
"""
vals = vals.astype(np.float32)
tensor = TensorProto()
tensor.data_type = DataType.FLOAT
tensor.name = name
tensor.raw_data = vals.tobytes()
tensor.dims.extend(vals.shape)
return tensor
def from_array(
arr,
name=None): # type: (np.ndarray[Any], Optional[Text]) -> TensorProto
"""Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
"""
tensor = TensorProto()
tensor.dims.extend(arr.shape)
if name:
tensor.name = name
if arr.dtype == np.object:
# Special care for strings.
tensor.data_type = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
for e in arr:
if isinstance(e, text_type):
tensor.string_data.append(e.encode('utf-8'))
elif isinstance(e, np.ndarray):
tensor.string_data.append(e.tobytes())
else:
raise NotImplementedError(
"Unrecognized object in the object array, expect a string, or array of bytes"
)
return tensor
# For numerical types, directly use numpy raw bytes.
try:
dtype = mapping.NP_TYPE_TO_TENSOR_TYPE[arr.dtype]
except KeyError:
raise RuntimeError("Numpy data type not understood yet: {}".format(
str(arr.dtype)))
tensor.data_type = dtype
tensor.raw_data = arr.tobytes() # note: tobytes() is only after 1.9.
return tensor
def add_onnx_graph(scope, operator, container, onx):
"""
Adds a whole ONNX graph to an existing one following
:epkg:`skl2onnx` API assuming this ONNX graph implements
an `operator <http://onnx.ai/sklearn-onnx/api_summary.html?
highlight=operator#skl2onnx.common._topology.Operator>`_.
:param scope: scope (to get unique names)
:param operator: operator
:param container: container
:param onx: ONNX graph
"""
graph = onx.graph
name_mapping = {}
node_mapping = {}
for node in graph.node:
name = node.name
if name is not None:
node_mapping[node.name] = _clean_initializer_name(node.name, scope)
for o in node.input:
name_mapping[o] = _clean_variable_name(o, scope)
for o in node.output:
name_mapping[o] = _clean_variable_name(o, scope)
for o in graph.initializer:
name_mapping[o.name] = _clean_operator_name(o.name, scope)
inputs = [_copy_inout(o, scope, name_mapping[o.name]) for o in graph.input]
outputs = [
_copy_inout(o, scope, name_mapping[o.name]) for o in graph.output
]
for inp, to in zip(operator.inputs, inputs):
n = helper.make_node('Identity', [inp.onnx_name], [to.name],
name=_clean_operator_name('Identity', scope))
container.nodes.append(n)
for inp, to in zip(outputs, operator.outputs):
n = helper.make_node('Identity', [inp.name], [to.onnx_name],
name=_clean_operator_name('Identity', scope))
container.nodes.append(n)
for node in graph.node:
n = helper.make_node(
node.op_type, [name_mapping[o] for o in node.input],
[name_mapping[o] for o in node.output],
name=node_mapping[node.name] if node.name else None,
domain=node.domain if node.domain else None)
n.attribute.extend(node.attribute) # pylint: disable=E1101
container.nodes.append(n)
for o in graph.initializer:
as_str = o.SerializeToString()
tensor = TensorProto()
tensor.ParseFromString(as_str)
tensor.name = name_mapping[o.name]
container.initializers.append(tensor)
# opset
for oimp in onx.opset_import:
container.node_domain_version_pair_sets.add(
(oimp.domain, oimp.version))
