Source code for onnxscript.ir.serde

# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
"""Serialize and deserialize the intermediate representation to/from ONNX protos."""

# NOTES for developers:
# NOTE: Do not import pathlib in the IR. It is slow. Use os.path methods instead.
#
# NOTE: Protobuf serialization
#     Initializing a protobuf message with initialized protobuf messages incurs
#     a copy and is slow. Instead, use proto.add() to add to a repeated field.
#     or initialize the message first and then set the fields if the fields are
#     plain Python objects.

from __future__ import annotations

import functools

__all__ = [
    # Tensors
    "TensorProtoTensor",
    # Deserialization
    "from_proto",
    "deserialize_attribute",
    "deserialize_dimension",
    "deserialize_function",
    "deserialize_graph",
    "deserialize_metadata_props",
    "deserialize_model",
    "deserialize_node",
    "deserialize_opset_import",
    "deserialize_tensor",
    "deserialize_type_proto_for_shape",
    "deserialize_type_proto_for_type",
    "deserialize_value_info_proto",
    # Serialization
    "to_proto",
    "serialize_attribute_into",
    "serialize_attribute",
    "serialize_dimension_into",
    "serialize_function_into",
    "serialize_function",
    "serialize_graph_into",
    "serialize_graph",
    "serialize_model_into",
    "serialize_model",
    "serialize_node_into",
    "serialize_node",
    "serialize_shape_into",
    "serialize_reference_attribute_into",
    "serialize_tensor_into",
    "serialize_tensor",
    "serialize_type_into",
    "serialize_type",
    "serialize_value_into",
    "serialize_value",
    "SerdeError",
]

import collections
import logging
import os
import typing
from typing import Any, Callable, List, Mapping, Sequence

import numpy as np
import onnx
import onnx.external_data_helper

from onnxscript.ir import _core, _enums, _metadata, _protocols, _type_casting

if typing.TYPE_CHECKING:
    import google.protobuf.internal.containers as proto_containers
    import numpy.typing as npt

logger = logging.getLogger(__name__)

_PLEASE_CONTRIBUTE = (
    "Please contribute by creating a PR at https://github.com/microsoft/onnxscript."
)
_FUNCTION_VALUE_INFO_SUPPORTED_VERSION = (
    10  # ONNX IR version where value info in functions was introduced
)
_T = typing.TypeVar("_T", bound=Callable[..., Any])


class SerdeError(RuntimeError):
    """Error during serialization or deserialization."""


def _capture_errors(arg_capturer: Callable[..., str]) -> Callable[[_T], _T]:
    """Decorator to capture errors and display the stack."""

    def decorator(func: _T) -> _T:
        @functools.wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            try:
                return func(*args, **kwargs)
            except Exception as e:
                raise SerdeError(
                    f"Error calling {func.__name__} with: {arg_capturer(*args, **kwargs)}"
                ) from e

        return wrapper  # type: ignore

    return decorator


def _little_endian_dtype(dtype) -> np.dtype:
    """Create a small endian dtype on all platforms.

    This is useful because ONNX always stores raw_data in small endian. On big
    endian platforms, we still need to interpret the raw_data in small endian.
    """
    return np.dtype(dtype).newbyteorder("<")


def _unflatten_complex(
    array: npt.NDArray[np.float32 | np.float64],
) -> npt.NDArray[np.complex64 | np.complex128]:
    """Convert the real representation of a complex dtype to the complex dtype."""
    return array[::2] + 1j * array[1::2]


def from_proto(
    proto: onnx.ModelProto
    | onnx.GraphProto
    | onnx.NodeProto
    | onnx.TensorProto
    | onnx.AttributeProto
    | onnx.ValueInfoProto
    | onnx.TypeProto
    | onnx.FunctionProto,
) -> Any:
    """Deserialize an ONNX proto message to an IR object."""
    if isinstance(proto, onnx.ModelProto):
        return deserialize_model(proto)
    if isinstance(proto, onnx.GraphProto):
        return deserialize_graph(proto)
    if isinstance(proto, onnx.NodeProto):
        return deserialize_node(proto)
    if isinstance(proto, onnx.TensorProto):
        return deserialize_tensor(proto)
    if isinstance(proto, onnx.AttributeProto):
        return deserialize_attribute(proto)
    if isinstance(proto, onnx.ValueInfoProto):
        return deserialize_value_info_proto(proto, None)
    if isinstance(proto, onnx.TypeProto):
        return _core.TypeAndShape(
            deserialize_type_proto_for_type(proto),
            deserialize_type_proto_for_shape(proto),
        )
    if isinstance(proto, onnx.FunctionProto):
        return deserialize_function(proto)
    raise NotImplementedError(
        f"Deserialization of {type(proto)} in from_proto is not implemented. "
        "Use a specific ir.serde.deserialize* function instead."
    )


def to_proto(
    ir_object: _protocols.ModelProtocol
    | _protocols.GraphProtocol
    | _protocols.NodeProtocol
    | _protocols.ValueProtocol
    | _protocols.AttributeProtocol
    | _protocols.ReferenceAttributeProtocol
    | _protocols.TensorProtocol
    | _protocols.TypeProtocol
    | _protocols.GraphViewProtocol
    | _protocols.FunctionProtocol,
) -> Any:
    """Serialize an IR object to a proto."""
    if isinstance(ir_object, _protocols.ModelProtocol):
        return serialize_model(ir_object)
    if isinstance(ir_object, _protocols.GraphProtocol):
        return serialize_graph(ir_object)
    if isinstance(ir_object, _protocols.NodeProtocol):
        return serialize_node(ir_object)
    if isinstance(ir_object, _protocols.TensorProtocol):
        return serialize_tensor(ir_object)
    if isinstance(ir_object, _protocols.ValueProtocol):
        return serialize_value(ir_object)
    if isinstance(ir_object, _protocols.AttributeProtocol):
        return serialize_attribute(ir_object)
    if isinstance(ir_object, _protocols.ReferenceAttributeProtocol):
        return serialize_reference_attribute_into(onnx.AttributeProto(), ir_object)
    if isinstance(ir_object, _protocols.TypeProtocol):
        return serialize_type_into(onnx.TypeProto(), ir_object)
    if isinstance(ir_object, _protocols.GraphViewProtocol):
        return serialize_graph(ir_object)
    if isinstance(ir_object, _protocols.FunctionProtocol):
        return serialize_function(ir_object)
    raise NotImplementedError(
        f"Serialization of {type(ir_object)} in to_proto is not implemented. "
        "Use a specific ir.serde.serialize* function instead."
    )


class TensorProtoTensor(_core.TensorBase):  # pylint: disable=too-many-ancestors
    """A tensor initialized from a tensor proto."""

    def __init__(self, proto: onnx.TensorProto) -> None:
        self._proto = proto
        self._metadata_props: dict[str, str] | None = deserialize_metadata_props(
            proto.metadata_props
        )
        self._metadata: _metadata.MetadataStore | None = None

    @property
    def name(self) -> str:
        return self._proto.name

    @name.setter
    def name(self, value: str | None) -> None:
        if value is None:
            self._proto.ClearField("name")
        else:
            self._proto.name = value

    @property
    def shape(self) -> _core.Shape:
        return _core.Shape(self._proto.dims, frozen=True)

    @property
    def dtype(self) -> _enums.DataType:
        return _enums.DataType(self._proto.data_type)

    @property
    def doc_string(self) -> str:
        return self._proto.doc_string

    @property
    def raw(self) -> onnx.TensorProto:
        return self._proto

    def __repr__(self) -> str:
        # It is a little hard to display the content when there can be types
        # unsupported by numpy
        # Preferably we should display some content when the tensor is small
        return f"{self._repr_base()}(name={self.name!r})"

    def __array__(self, dtype: Any = None) -> np.ndarray:
        """Return the tensor as a numpy array, compatible with np.array."""
        return self.numpy().__array__(dtype)

    def __dlpack__(self, *, stream: Any = None) -> Any:
        return self.numpy().__dlpack__(stream=stream)

    def __dlpack_device__(self) -> tuple[int, int]:
        return self.numpy().__dlpack_device__()

[docs] def numpy(self) -> np.ndarray: """Return the tensor as a numpy array. This is an improved version of onnx.numpy_helper.to_array. It first reads the data using the dtype corresponding to the tensor proto data field, then converts it to the correct dtype and shape. Special cases are bfloat16, complex and int4 where we need to reinterpret the data. Other types can simply be casted. When the data type is not supported by numpy, the dtypes from the ``ml_dtype`` package are used. The values can be reinterpreted as bit representations using the ``.view()`` method. When the data type is a string, this method returns a numpy array of bytes instead of a numpy array of strings, to follow the ONNX specification. External tensors are not supported by this class. Use :class:`onnxscript.ir.ExternalTensor` instead. Raises: ValueError: If the data type is UNDEFINED. """ dtype = self.dtype if dtype == _enums.DataType.UNDEFINED: raise ValueError("Cannot convert UNDEFINED tensor to numpy array.") if self._proto.data_location == onnx.TensorProto.EXTERNAL: raise ValueError( "Cannot convert external tensor to numpy array. " "Use ir.ExternalTensor instead." ) if self._proto.HasField("raw_data"): array = np.frombuffer(self._proto.raw_data, dtype=dtype.numpy().newbyteorder("<")) # Cannot return now, because we may need to unpack 4bit tensors elif dtype == _enums.DataType.STRING: return np.array(self._proto.string_data).reshape(self._proto.dims) elif self._proto.int32_data: array = np.array(self._proto.int32_data, dtype=_little_endian_dtype(np.int32)) if dtype in {_enums.DataType.FLOAT16, _enums.DataType.BFLOAT16}: # Reinterpret the int32 as float16 or bfloat16 array = array.astype(np.uint16).view(dtype.numpy()) elif dtype in { _enums.DataType.FLOAT8E4M3FN, _enums.DataType.FLOAT8E4M3FNUZ, _enums.DataType.FLOAT8E5M2, _enums.DataType.FLOAT8E5M2FNUZ, }: array = array.astype(np.uint8).view(dtype.numpy()) elif self._proto.int64_data: array = np.array(self._proto.int64_data, dtype=_little_endian_dtype(np.int64)) elif self._proto.uint64_data: array = np.array(self._proto.uint64_data, dtype=_little_endian_dtype(np.uint64)) elif self._proto.float_data: array = np.array(self._proto.float_data, dtype=_little_endian_dtype(np.float32)) if dtype == _enums.DataType.COMPLEX64: array = _unflatten_complex(array) elif self._proto.double_data: array = np.array(self._proto.double_data, dtype=_little_endian_dtype(np.float64)) if dtype == _enums.DataType.COMPLEX128: array = _unflatten_complex(array) else: # Empty tensor if not self._proto.dims: # When dims not precent and there is no data, we return an empty array return np.array([], dtype=dtype.numpy()) else: # Otherwise we return a size 0 array with the correct shape return np.zeros(self._proto.dims, dtype=dtype.numpy()) if dtype == _enums.DataType.INT4: return _type_casting.unpack_int4(array.astype(np.uint8), self._proto.dims) elif dtype == _enums.DataType.UINT4: return _type_casting.unpack_uint4(array.astype(np.uint8), self._proto.dims) else: # Otherwise convert to the correct dtype and reshape # Note we cannot use view() here because the storage dtype may not be the same size as the target return array.astype(dtype.numpy()).reshape(self._proto.dims)
[docs] def tobytes(self) -> bytes: """Return the tensor as a byte string conformed to the ONNX specification, in little endian. Raises: ValueError: If the tensor is a string tensor or an external tensor. ValueError: If the tensor is of UNDEFINED data type. """ if self._proto.data_location == onnx.TensorProto.EXTERNAL: raise ValueError( "Cannot convert external tensor to bytes. Use ir.ExternalTensor instead." ) if self.dtype == _enums.DataType.STRING: raise ValueError("Cannot convert string tensor to bytes.") if self.dtype == _enums.DataType.UNDEFINED: raise ValueError("Cannot convert UNDEFINED tensor to bytes.") if self._proto.HasField("raw_data"): return self._proto.raw_data if self._proto.float_data: return np.array( self._proto.float_data, dtype=_little_endian_dtype(np.float32) ).tobytes() if self._proto.int32_data: array = np.array(self._proto.int32_data, dtype=np.int32) if self.dtype in { _enums.DataType.INT16, _enums.DataType.UINT16, _enums.DataType.FLOAT16, _enums.DataType.BFLOAT16, }: return array.astype(_little_endian_dtype(np.uint16)).tobytes() if self.dtype in { _enums.DataType.INT8, _enums.DataType.UINT8, _enums.DataType.BOOL, _enums.DataType.FLOAT8E4M3FN, _enums.DataType.FLOAT8E4M3FNUZ, _enums.DataType.FLOAT8E5M2, _enums.DataType.FLOAT8E5M2FNUZ, _enums.DataType.INT4, _enums.DataType.UINT4, }: # uint4 and int4 values are already packed, even when stored as int32 # so we don't need to pack them again return array.astype(_little_endian_dtype(np.uint8)).tobytes() assert self.dtype == _enums.DataType.INT32 return array.tobytes() if self._proto.int64_data: return np.array( self._proto.int64_data, dtype=_little_endian_dtype(np.int64) ).tobytes() if self._proto.double_data: return np.array( self._proto.double_data, dtype=_little_endian_dtype(np.float64) ).tobytes() if self._proto.uint64_data: array = np.array(self._proto.uint64_data, dtype=_little_endian_dtype(np.uint64)) if self.dtype == _enums.DataType.UINT32: return array.astype(_little_endian_dtype(np.uint32)).tobytes() assert self.dtype == _enums.DataType.UINT64 return array.tobytes() # The repeating fields can be empty and still valid. # For example, int32_data can be empty and still be a valid tensor. return b""
@property def meta(self) -> _metadata.MetadataStore: """The metadata store for intermediate analysis. Write to the :attr:`metadata_props` if you would like the metadata to be serialized to the ONNX proto. """ if self._metadata is None: self._metadata = _metadata.MetadataStore() return self._metadata @property def metadata_props(self) -> dict[str, str]: if self._metadata_props is None: self._metadata_props = {} return self._metadata_props def _get_field(proto: Any, field: str) -> Any: if proto.HasField(field): return getattr(proto, field) return None # Deserialization def deserialize_opset_import( protos: Sequence[onnx.OperatorSetIdProto], ) -> dict[str, int]: return {opset.domain: opset.version for opset in protos} def _parse_experimental_function_value_info_name( name: str, ) -> tuple[str, str, str] | None: """Get the function domain, name and value name if the value info is for a function. The experimental format is: {function_domain}::{function_name}/{value_name} Args: name: The name stored in the value info. Returns: A tuple of the function domain, function name and value name if the value info is for a function. None otherwise. """ parts = name.split("/") expected_parts = 2 if len(parts) != expected_parts: return None function, value_name = parts parts = function.split("::") if len(parts) != expected_parts: return None # NOTE: There will not be overload because overloads are introduced in ONNX IR v10, which also # introduces the ValueInfoProto for functions function_domain, function_name = parts return function_domain, function_name, value_name def deserialize_model(proto: onnx.ModelProto) -> _core.Model: graph = _deserialize_graph(proto.graph, []) graph.opset_imports.update(deserialize_opset_import(proto.opset_import)) functions = [] for func in proto.functions: functions.append(deserialize_function(func)) model = _core.Model( graph, ir_version=proto.ir_version, producer_name=_get_field(proto, "producer_name"), producer_version=_get_field(proto, "producer_version"), domain=_get_field(proto, "domain"), model_version=_get_field(proto, "model_version"), doc_string=_get_field(proto, "doc_string"), functions=functions, meta_data_props=deserialize_metadata_props(proto.metadata_props), ) # Handle experimental value info for functions created by the dynamo exporter in IR version 9 if model.ir_version < _FUNCTION_VALUE_INFO_SUPPORTED_VERSION: _deserialized_experimental_value_info_for_function_ir9( model.functions, proto.graph.value_info ) return model def _deserialized_experimental_value_info_for_function_ir9( functions: Mapping[_protocols.OperatorIdentifier, _core.Function], value_info_protos: Sequence[onnx.ValueInfoProto], ) -> None: """Deserialize value info for functions when they are stored in an experimental format. The experimental format is: {function_domain}::{function_name}/{value_name} """ # Parse value info for functions from the main graph function_value_value_info_mapping: collections.defaultdict[ _protocols.OperatorIdentifier, dict[str, onnx.ValueInfoProto], ] = collections.defaultdict(dict) for value_info_proto in value_info_protos: if ( parsed := _parse_experimental_function_value_info_name(value_info_proto.name) ) is None: continue function_domain, function_name, value_name = parsed function_overload = "" # TODO(justinchuby): Create a constructor for OperatorIdentifier so we don't create tuples manually function_id = (function_domain, function_name, function_overload) function = functions.get(function_id) if function is None: # Function not found logger.debug( "Function with ID '%s' not found in model functions. Value info '%s' will be ignored.", function_id, value_info_proto.name, ) continue function_value_value_info_mapping[function_id][value_name] = value_info_proto for function_id, function in functions.items(): for input in function.inputs: if input.name in function_value_value_info_mapping[function_id]: deserialize_value_info_proto( function_value_value_info_mapping[function_id][input.name], input ) for node in function: for output in node.outputs: if output.name in function_value_value_info_mapping[function_id]: deserialize_value_info_proto( function_value_value_info_mapping[function_id][output.name], output, ) # The function outputs are handled as well because they are also node outputs def deserialize_graph(proto: onnx.GraphProto) -> _core.Graph: """Deserialize a graph proto, recursively if needed. Args: proto: The graph proto to deserialize. Returns: IR Graph. """ return _deserialize_graph(proto, []) @_capture_errors(lambda proto, scoped_values: proto.name) def _deserialize_graph( proto: onnx.GraphProto, scoped_values: list[dict[str, _core.Value]] ) -> _core.Graph: """Deserialize a graph proto, recursively if needed. Args: proto: The graph proto to deserialize. scoped_values: A list of dictionaries mapping value names to their corresponding Value objects. Every time we enter a new graph, a new scope is created and appended to this list to include all values defined in the scope. scoped_value_info: A list of dictionaries mapping value names to their corresponding ValueInfoProto. Returns: IR Graph. """ # Create values for initializers and inputs initializer_tensors = [deserialize_tensor(tensor) for tensor in proto.initializer] inputs = [_core.Input(info.name) for info in proto.input] for info, value in zip(proto.input, inputs): deserialize_value_info_proto(info, value) # Initialize the values dictionary for this graph scope with the inputs and initializers values: dict[str, _core.Value] = {v.name: v for v in inputs} # type: ignore[misc] scoped_values.append(values) initializer_values = [] for tensor in initializer_tensors: if tensor.name in values: # The initializer is for an input initializer_value = values[tensor.name] initializer_value.const_value = tensor else: # The initializer is for some other value. Create this value first initializer_value = _core.Value( None, index=None, name=tensor.name, # TODO(justinchuby): Fix type hinting for shape and dtype shape=tensor.shape, # type: ignore type=_core.TensorType(tensor.dtype), const_value=tensor, ) values[tensor.name] = initializer_value # type: ignore[index] initializer_values.append(initializer_value) # Add ValueInfos for this graph scope value_info = {info.name: info for info in proto.value_info} # Deserialize nodes with all known values nodes = [_deserialize_node(node, scoped_values, value_info) for node in proto.node] # Fill in values for graph outputs outputs = [deserialize_value_info_proto(info, values[info.name]) for info in proto.output] scoped_values.pop() return _core.Graph( inputs, outputs, nodes=nodes, initializers=initializer_values, doc_string=_get_field(proto, "doc_string"), name=_get_field(proto, "name"), metadata_props=deserialize_metadata_props(proto.metadata_props), ) @_capture_errors(lambda proto: proto.name) def deserialize_function(proto: onnx.FunctionProto) -> _core.Function: inputs = [_core.Input(name) for name in proto.input] values: dict[str, _core.Value] = {v.name: v for v in inputs} # type: ignore[misc] value_info = {info.name: info for info in getattr(proto, "value_info", [])} # TODO(justinchuby): Handle unsorted nodes nodes = [_deserialize_node(node, [values], value_info=value_info) for node in proto.node] outputs = [values[name] for name in proto.output] graph = _core.Graph( inputs, outputs, nodes=nodes, initializers=(), doc_string=_get_field(proto, "doc_string"), opset_imports=deserialize_opset_import(proto.opset_import), name=( f"{proto.name}_{proto.domain}" + f"__{proto.overload}" if hasattr(proto, "overload") and proto.overload else "" ), ) attributes = [_deserialize_attribute(attr, []) for attr in proto.attribute_proto] # Attributes without defaults attributes += [ _core.Attr(name, _enums.AttributeType.UNDEFINED, None) for name in proto.attribute ] return _core.Function( domain=proto.domain, name=proto.name, overload=getattr(proto, "overload", ""), graph=graph, attributes=typing.cast(List[_core.Attr], attributes), metadata_props=deserialize_metadata_props(proto.metadata_props), ) @_capture_errors(lambda proto, value: str(proto)) def deserialize_value_info_proto( proto: onnx.ValueInfoProto, value: _core.Value | None ) -> _core.Value: if value is None: value = _core.Value(name=proto.name) value.shape = deserialize_type_proto_for_shape(proto.type) value.type = deserialize_type_proto_for_type(proto.type) metadata_props = deserialize_metadata_props(proto.metadata_props) if metadata_props is not None: value.metadata_props.update(metadata_props) value.doc_string = _get_field(proto, "doc_string") return value @_capture_errors(str) def deserialize_type_proto_for_shape(proto: onnx.TypeProto) -> _core.Shape | None: if proto.HasField("tensor_type"): if (shape_proto := _get_field(proto.tensor_type, "shape")) is None: return None # This logic handles when the shape is [] as well dim_protos = shape_proto.dim deserialized_dim_denotations = [ deserialize_dimension(dim_proto) for dim_proto in dim_protos ] dims = [dim for dim, _ in deserialized_dim_denotations] denotations = [denotation for _, denotation in deserialized_dim_denotations] return _core.Shape(dims, denotations=denotations, frozen=True) if proto.HasField("sparse_tensor_type"): if (shape_proto := _get_field(proto.sparse_tensor_type, "shape")) is None: return None dim_protos = shape_proto.dim deserialized_dim_denotations = [ deserialize_dimension(dim_proto) for dim_proto in dim_protos ] dims = [dim for dim, _ in deserialized_dim_denotations] denotations = [denotation for _, denotation in deserialized_dim_denotations] return _core.Shape(dims, denotations=denotations, frozen=True) if proto.HasField("sequence_type"): if (elem_type := _get_field(proto.sequence_type, "elem_type")) is None: return None return deserialize_type_proto_for_shape(elem_type) if proto.HasField("optional_type"): if (elem_type := _get_field(proto.optional_type, "elem_type")) is None: return None return deserialize_type_proto_for_shape(elem_type) if proto.HasField("map_type"): # TODO(justinchuby): Do we need to support map types? raise NotImplementedError(f"Map types are not supported yet. {_PLEASE_CONTRIBUTE}") return None @_capture_errors(str) def deserialize_type_proto_for_type( proto: onnx.TypeProto, ) -> _protocols.TypeProtocol | None: denotation = _get_field(proto, "denotation") if proto.HasField("tensor_type"): if (elem_type := _get_field(proto.tensor_type, "elem_type")) is None: return None return _core.TensorType(_enums.DataType(elem_type), denotation=denotation) if proto.HasField("sparse_tensor_type"): if (elem_type := _get_field(proto.sparse_tensor_type, "elem_type")) is None: return None return _core.SparseTensorType(_enums.DataType(elem_type), denotation=denotation) if proto.HasField("sequence_type"): # FIXME(justinchuby): Allow nested types being None if (elem_type := _get_field(proto.sequence_type, "elem_type")) is None: raise ValueError(f"SequenceTypeProto must have elem_type set: {proto}") nested_type = deserialize_type_proto_for_type(elem_type) if nested_type is None: raise ValueError(f"SequenceType must have elem_type set: {proto}") return _core.SequenceType(nested_type, denotation=denotation) if proto.HasField("optional_type"): # FIXME(justinchuby): Allow nested types being None if (elem_type := _get_field(proto.optional_type, "elem_type")) is None: raise ValueError(f"SequenceTypeProto must have elem_type set: {proto}") nested_type = deserialize_type_proto_for_type(elem_type) if nested_type is None: raise ValueError(f"SequenceType must have elem_type set: {proto}") return _core.OptionalType(nested_type, denotation=denotation) if proto.HasField("map_type"): # TODO(justinchuby): Do we need to support map types? raise NotImplementedError(f"Map types are not supported yet. {_PLEASE_CONTRIBUTE}") return None @_capture_errors(str) def deserialize_dimension( proto: onnx.TensorShapeProto.Dimension, ) -> tuple[int | _core.SymbolicDim, str | None]: """Deserialize a dimension proto into (dimension, denotation). Args: proto: The dimension proto to deserialize. Returns: A tuple of the dimension and its denotation. """ value_field = proto.WhichOneof("value") denotation = _get_field(proto, "denotation") if value_field is not None: value = getattr(proto, value_field) if value_field == "dim_value": return value, denotation if value_field == "dim_param": return _core.SymbolicDim(value), denotation return _core.SymbolicDim(None), denotation @_capture_errors(lambda proto, base_path: proto.name) def deserialize_tensor( proto: onnx.TensorProto, base_path: str | os.PathLike = "" ) -> _protocols.TensorProtocol: # TODO: Sanitize base_path if proto.data_location == onnx.TensorProto.EXTERNAL: external_info = onnx.external_data_helper.ExternalDataInfo(proto) return _core.ExternalTensor( path=os.path.join(base_path, external_info.location), offset=external_info.offset, length=external_info.length, dtype=_enums.DataType(proto.data_type), name=_get_field(proto, "name"), shape=_core.Shape(proto.dims), doc_string=_get_field(proto, "doc_string"), metadata_props=deserialize_metadata_props(proto.metadata_props), ) if proto.data_type == _enums.DataType.STRING: name = _get_field(proto, "name") doc_string = _get_field(proto, "doc_string") metadata_props = deserialize_metadata_props(proto.metadata_props) return _core.StringTensor( proto.string_data, shape=_core.Shape(proto.dims), name=name, doc_string=doc_string, metadata_props=metadata_props, ) return TensorProtoTensor(proto) def deserialize_metadata_props( proto: Sequence[onnx.StringStringEntryProto], ) -> dict[str, str] | None: if len(proto) == 0: # Avoid creating an empty dictionary to save memory return None return {entry.key: entry.value for entry in proto} def deserialize_attribute(proto: onnx.AttributeProto) -> _core.Attr | _core.RefAttr: return _deserialize_attribute(proto, []) @_capture_errors(lambda proto, scoped_values: str(proto)) def _deserialize_attribute( proto: onnx.AttributeProto, scoped_values: list[dict[str, _core.Value]] ) -> _core.Attr | _core.RefAttr: name = proto.name doc_string = _get_field(proto, "doc_string") type_ = _enums.AttributeType(proto.type) ref_attr_name = _get_field(proto, "ref_attr_name") if ref_attr_name: return _core.RefAttr(name, ref_attr_name, type_, doc_string=doc_string) if type_ == _enums.AttributeType.INT: return _core.AttrInt64(name, proto.i, doc_string=doc_string) if type_ == _enums.AttributeType.FLOAT: return _core.AttrFloat32(name, proto.f, doc_string=doc_string) if type_ == _enums.AttributeType.STRING: return _core.AttrString(name, proto.s.decode("utf-8"), doc_string=doc_string) if type_ == _enums.AttributeType.INTS: return _core.AttrInt64s(name, proto.ints, doc_string=doc_string) if type_ == _enums.AttributeType.FLOATS: return _core.AttrFloat32s(name, proto.floats, doc_string=doc_string) if type_ == _enums.AttributeType.STRINGS: return _core.AttrStrings( name, [s.decode("utf-8") for s in proto.strings], doc_string=doc_string ) if type_ == _enums.AttributeType.TENSOR: return _core.AttrTensor(name, deserialize_tensor(proto.t), doc_string=doc_string) if type_ == _enums.AttributeType.GRAPH: return _core.AttrGraph( name, _deserialize_graph(proto.g, scoped_values), doc_string=doc_string ) if type_ == _enums.AttributeType.TENSORS: return _core.AttrTensors( name, [deserialize_tensor(t) for t in proto.tensors], doc_string=doc_string, ) if type_ == _enums.AttributeType.GRAPHS: return _core.AttrGraphs( name, [_deserialize_graph(g, scoped_values) for g in proto.graphs], doc_string=doc_string, ) if type_ == _enums.AttributeType.SPARSE_TENSOR: raise NotImplementedError( f"Sparse tensors are not supported yet. {_PLEASE_CONTRIBUTE}" ) if type_ == _enums.AttributeType.SPARSE_TENSORS: raise NotImplementedError( f"Sparse tensors are not supported yet. {_PLEASE_CONTRIBUTE}" ) if type_ == _enums.AttributeType.TYPE_PROTO: ir_type = deserialize_type_proto_for_type(proto.tp) shape = deserialize_type_proto_for_shape(proto.tp) return _core.AttrTypeProto( name, _core.TypeAndShape(ir_type, shape), doc_string=doc_string ) if type_ == _enums.AttributeType.TYPE_PROTOS: type_and_shapes = [] for type_proto in proto.type_protos: ir_type = deserialize_type_proto_for_type(type_proto) shape = deserialize_type_proto_for_shape(type_proto) type_and_shapes.append(_core.TypeAndShape(ir_type, shape)) return _core.AttrTypeProtos(name, type_and_shapes, doc_string=doc_string) if type_ == _enums.AttributeType.UNDEFINED: return _core.Attr(name, type_, None, doc_string=doc_string) raise ValueError(f"Unsupported attribute type: '{type_}'") def deserialize_node(proto: onnx.NodeProto) -> _core.Node: return _deserialize_node(proto, scoped_values=[], value_info={}) @_capture_errors(lambda proto, scoped_values, value_info: str(proto)) def _deserialize_node( proto: onnx.NodeProto, scoped_values: list[dict[str, _core.Value]], value_info: dict[str, onnx.ValueInfoProto], ) -> _core.Node: node_inputs: list[_core.Value | None] = [] for input_name in proto.input: if input_name == "": # Empty input node_inputs.append(None) continue # Find the input in all value scopes found = False for values in reversed(scoped_values): if input_name not in values: continue node_inputs.append(values[input_name]) found = True del values # Remove the reference so it is not used by mistake break if not found: # If the input is not found, we know the graph may be unsorted and # the input may be a supposed-to-be initializer or an output of a node that comes later. # Here we create the value with the name and add it to the current scope. # Nodes need to check the value pool for potentially initialized outputs logger.warning( "Input '%s' of node '%s(%s::%s:%s)' not found in any scope. " "The graph may be unsorted. Creating a new input (current depth: %s) .", input_name, proto.name, proto.domain, proto.op_type, getattr(proto, "overload", ""), len(scoped_values), ) if len(scoped_values) > 1: logger.warning( "Caveat: The value is created in the subgraph. If " "the node is referencing a value that is not in the current graph, " "it is impossible to create it in the correct scope.", ) value = _core.Value(name=input_name) # Fill in shape/type information if they exist if input_name in value_info: deserialize_value_info_proto(value_info[input_name], value) node_inputs.append(value) # We can only create the value in the current scope. If the subgraph is # referencing a value that is not in the current scope, it is impossible # to create it in the correct scope. scoped_values[-1][input_name] = value # Build the output values for the node. node_outputs: list[_core.Value] = [] for output_name in proto.output: if output_name == "": # Empty output node_outputs.append(_core.Value(name="")) continue # 1. When the graph is unsorted, we may be able to find the output already created # as an input to some other nodes in the current scope. # Note that a value is always owned by the producing node. Even though a value # can be created when parsing inputs of other nodes, the new node created here # that produces the value will assume ownership. It is then impossible to transfer # the ownership to any other node. # The output can only be found in the current scope. It is impossible for # a node to produce an output that is not in its own scope. current_scope = scoped_values[-1] if output_name in current_scope: value = current_scope[output_name] else: # 2. Common scenario: the graph is sorted and this is the first time we see the output. # Create the value and add it to the current scope. value = _core.Value(name=output_name) current_scope[output_name] = value # Fill in shape/type information if they exist if output_name in value_info: deserialize_value_info_proto(value_info[output_name], value) else: logger.debug( "ValueInfoProto not found for output '%s' in node '%s' of type '%s'", output_name, proto.name, proto.op_type, ) node_outputs.append(value) return _core.Node( proto.domain, proto.op_type, node_inputs, [_deserialize_attribute(a, scoped_values) for a in proto.attribute], overload=getattr(proto, "overload", ""), outputs=node_outputs, name=proto.name, doc_string=_get_field(proto, "doc_string"), metadata_props=deserialize_metadata_props(proto.metadata_props), ) # Serialization def serialize_model(model: _protocols.ModelProtocol) -> onnx.ModelProto: return serialize_model_into(onnx.ModelProto(), from_=model) @_capture_errors( lambda model_proto, from_: ( f"ir_version={from_.ir_version}, producer_name={from_.producer_name}, " f"producer_version={from_.producer_version}, domain={from_.domain}, " ) ) def serialize_model_into( model_proto: onnx.ModelProto, from_: _protocols.ModelProtocol ) -> onnx.ModelProto: """Serialize an IR model to an ONNX model proto.""" model_proto.ir_version = from_.ir_version if from_.producer_name: model_proto.producer_name = from_.producer_name if from_.producer_version: model_proto.producer_version = from_.producer_version if from_.domain: model_proto.domain = from_.domain if from_.model_version: model_proto.model_version = from_.model_version if from_.doc_string: model_proto.doc_string = from_.doc_string # Sort names for deterministic serialization _serialize_opset_imports_into(model_proto.opset_import, from_.opset_imports) if from_.metadata_props: _serialize_metadata_props_into(model_proto.metadata_props, from_.metadata_props) serialize_graph_into(model_proto.graph, from_.graph) create_value_info_in_functions = from_.ir_version >= _FUNCTION_VALUE_INFO_SUPPORTED_VERSION for func in from_.functions.values(): serialize_function_into( model_proto.functions.add(), from_=func, create_value_info=create_value_info_in_functions, ) if not create_value_info_in_functions: # Create them in the main graph instead _serialize_experimental_value_info_for_function_ir9_into(model_proto.graph, func) return model_proto def _should_create_value_info_for_value(value: _protocols.ValueProtocol) -> bool: """Check if value info should be created for a value. Args: value: The value to check. Returns: True if value info should be created for the value. """ # No need to serialize value info if it is not set return not (value.shape is None and value.type is None) def _serialize_experimental_value_info_for_function_ir9_into( graph_proto: onnx.GraphProto, function: _protocols.FunctionProtocol ) -> None: """Serialize value info for functions in an experimental format for IR version 9. Because IRv9 and older does not have ValueInfoProto for functions, we give the value info special names and store them in the main graph instead. The experimental format is: {function_domain}::{function_name}/{value_name} Args: graph_proto: The graph proto to create ValueInfoProto in. function: The function to serialize. """ # TODO(justinchuby): In the future, we can decide if it is a good idea to simply iterate over # all values in the function and call serialize_value_into instead. function_qualified_name = f"{function.domain}::{function.name}" def format_name(value_name: str) -> str: return f"{function_qualified_name}/{value_name}" for input in function.inputs: if not input.name: logging.warning( "Function '%s': Value name not set for function input: %s", function_qualified_name, input, ) continue if not _should_create_value_info_for_value(input): # No need to serialize value info if it is not set continue serialize_value_into(graph_proto.value_info.add(), input, name=format_name(input.name)) for node in function: for node_output in node.outputs: if not node_output.name: logging.warning( "Function '%s': Value name not set for node output: %s", function_qualified_name, node_output, ) continue if not _should_create_value_info_for_value(node_output): # No need to serialize value info if it is not set continue serialize_value_into( graph_proto.value_info.add(), node_output, name=format_name(node_output.name), ) def _serialize_opset_imports_into( opset_ids: proto_containers.RepeatedCompositeFieldContainer[onnx.OperatorSetIdProto], from_: Mapping[str, int], ) -> None: """Serialize opset imports into a repeated field of OperatorSetId protos. Args: opset_ids: The repeated field to serialize into. from_: The mapping of opset domains to versions to serialize. """ # Sort names for deterministic serialization for domain, version in from_.items(): opset_ids.add(domain=domain, version=version) def _serialize_metadata_props_into( string_string_entries: proto_containers.RepeatedCompositeFieldContainer[ onnx.StringStringEntryProto ], from_: Mapping[str, str], ) -> None: """Serialize metadata properties into a repeated field of string-string entries. Args: string_string_entries: The repeated field to serialize into. from_: The mapping of metadata properties to serialize. """ # Sort names for deterministic serialization for key in sorted(from_): string_string_entries.add(key=key, value=from_[key]) def serialize_graph( graph: _protocols.GraphProtocol | _protocols.GraphViewProtocol, ) -> onnx.GraphProto: """Serializes the given graph into an :class:`onnx.GraphProto`. When the graph initializers do not have `const_value` set, they will be skipped. Args: graph: The graph to be serialized. Returns: The serialized ONNX GraphProto object. """ graph_proto = onnx.GraphProto() serialize_graph_into(graph_proto, from_=graph) return graph_proto @_capture_errors( lambda graph_proto, from_: ( f"name={from_.name}, doc_string={from_.doc_string}, " f"len(inputs)={len(from_.inputs)}, len(initializers)={len(from_.initializers)}, " f"len(nodes)={len(from_)}, len(outputs)={len(from_.outputs)}, metadata_props={from_.metadata_props}" ) ) def serialize_graph_into( graph_proto: onnx.GraphProto, from_: _protocols.GraphProtocol | _protocols.GraphViewProtocol, ) -> None: if from_.name: graph_proto.name = from_.name if from_.doc_string: graph_proto.doc_string = from_.doc_string for input_ in from_.inputs: serialize_value_into(graph_proto.input.add(), input_) # TODO(justinchuby): Support sparse_initializer for initializer in from_.initializers.values(): if initializer.const_value is None: # Skip initializers without constant values logger.warning( "Initializer '%s' does not have a constant value set.", initializer.name ) continue # Make sure the tensor's name is the same as the value's name initializer.const_value.name = initializer.name serialize_tensor_into(graph_proto.initializer.add(), from_=initializer.const_value) for node in from_: serialize_node_into(graph_proto.node.add(), from_=node) for node_output in node.outputs: if not _should_create_value_info_for_value(node_output): # No need to serialize value info if it is not set continue if node_output.is_graph_output(): # No need to serialize value info for these outputs because they are also graph outputs continue serialize_value_into(graph_proto.value_info.add(), node_output) for output in from_.outputs: serialize_value_into(graph_proto.output.add(), from_=output) if from_.metadata_props: _serialize_metadata_props_into(graph_proto.metadata_props, from_.metadata_props) def serialize_function( function: _protocols.FunctionProtocol, *, create_value_info: bool = True ) -> onnx.FunctionProto: """Serialize an IR function as a FunctionProto. Args: function: The function to serialize. create_value_info: Whether to create ValueInfoProto for nodes in the function. This is supported starting from ONNX IR version 10. """ function_proto = onnx.FunctionProto() serialize_function_into( function_proto, from_=function, create_value_info=create_value_info ) return function_proto @_capture_errors(lambda function_proto, from_, create_value_info: repr(from_)) def serialize_function_into( function_proto: onnx.FunctionProto, from_: _protocols.FunctionProtocol, *, create_value_info: bool = True, ) -> None: """Serialize an IR function into a FunctionProto. Args: function_proto: The proto to serialize into. from_: The function to serialize. create_value_info: Whether to create ValueInfoProto for nodes in the function. This is supported starting from ONNX IR version 10. """ if from_.domain: function_proto.domain = from_.domain if from_.name: function_proto.name = from_.name if from_.overload: function_proto.overload = from_.overload if from_.doc_string: function_proto.doc_string = from_.doc_string if from_.opset_imports: # A valid ONNX graph should have at least one opset import, that is # the default ONNX opset. # Here we check for emptiness before serializing to keep the logic consistent _serialize_opset_imports_into(function_proto.opset_import, from_.opset_imports) if from_.metadata_props: _serialize_metadata_props_into(function_proto.metadata_props, from_.metadata_props) for input_ in from_.inputs: function_proto.input.append(input_.name) if not _should_create_value_info_for_value(input_): # No need to serialize value info if it is not set continue if not create_value_info: continue serialize_value_into(function_proto.value_info.add(), input_) for attr in from_.attributes.values(): if attr.value is not None: serialize_attribute_into(function_proto.attribute_proto.add(), from_=attr) else: # ONNX does not record type information if the attribute does not have a default function_proto.attribute.append(attr.name) for func_output in from_.outputs: function_proto.output.append(func_output.name) # No need to serialize value info for function outputs because they are # also node outputs for node in from_: serialize_node_into(function_proto.node.add(), from_=node) # Record value info for outputs for node_output in node.outputs: if not _should_create_value_info_for_value(node_output): # No need to serialize value info if it is not set continue if not create_value_info: continue serialize_value_into(function_proto.value_info.add(), node_output) def serialize_node(node: _protocols.NodeProtocol) -> onnx.NodeProto: node_proto = onnx.NodeProto() serialize_node_into(node_proto, from_=node) return node_proto @_capture_errors(lambda node_proto, from_: repr(from_)) def serialize_node_into(node_proto: onnx.NodeProto, from_: _protocols.NodeProtocol) -> None: node_proto.op_type = from_.op_type if from_.domain: # If the domain is "", we can assume the default domain and not set it node_proto.domain = from_.domain if from_.name: node_proto.name = from_.name if from_.overload: node_proto.overload = from_.overload if from_.doc_string: node_proto.doc_string = from_.doc_string if from_.metadata_props: _serialize_metadata_props_into(node_proto.metadata_props, from_.metadata_props) for input_ in from_.inputs: if input_ is None: node_proto.input.append("") else: node_proto.input.append(input_.name) for output in from_.outputs: node_proto.output.append(output.name) for attr in from_.attributes.values(): if isinstance(attr, _core.Attr): serialize_attribute_into(node_proto.attribute.add(), from_=attr) elif isinstance(attr, _core.RefAttr): serialize_reference_attribute_into(node_proto.attribute.add(), from_=attr) # Handle protocol attributes for completeness. We do not check them first because # calling isinstance on a protocol can be slow. # Most of the time, we will have Attr or RefAttr so the two branches below # will not be taken. elif isinstance(attr, _protocols.AttributeProtocol): serialize_attribute_into(node_proto.attribute.add(), from_=attr) elif isinstance(attr, _protocols.ReferenceAttributeProtocol): serialize_reference_attribute_into(node_proto.attribute.add(), from_=attr) else: raise TypeError(f"Unsupported attribute type: {type(attr)}") def serialize_tensor(tensor: _protocols.TensorProtocol) -> onnx.TensorProto: tensor_proto = onnx.TensorProto() serialize_tensor_into(tensor_proto, from_=tensor) return tensor_proto @_capture_errors(lambda tensor_proto, from_: repr(from_)) def serialize_tensor_into( tensor_proto: onnx.TensorProto, from_: _protocols.TensorProtocol ) -> None: if isinstance(from_, TensorProtoTensor): # Directly copy from the tensor proto if it is available tensor_proto.CopyFrom(from_.raw) if from_.metadata_props: _serialize_metadata_props_into(tensor_proto.metadata_props, from_.metadata_props) return if from_.name: tensor_proto.name = from_.name if from_.doc_string: tensor_proto.doc_string = from_.doc_string tensor_proto.data_type = from_.dtype.value tensor_proto.dims.extend(from_.shape.numpy()) if isinstance(from_, _core.ExternalTensor): # Store external tensors as is tensor_proto.data_location = onnx.TensorProto.EXTERNAL for k, v in { "location": os.fspath(from_.path), "offset": from_.offset, "length": from_.length, }.items(): if v is not None: entry = tensor_proto.external_data.add() entry.key = k entry.value = str(v) elif isinstance(from_, _core.StringTensor): tensor_proto.string_data.extend(from_.string_data()) else: tensor_proto.raw_data = from_.tobytes() _serialize_metadata_props_into(tensor_proto.metadata_props, from_.metadata_props) def serialize_attribute(attribute: _protocols.AttributeProtocol) -> onnx.AttributeProto: attribute_proto = onnx.AttributeProto() serialize_attribute_into(attribute_proto, from_=attribute) return attribute_proto @_capture_errors(lambda attribute_proto, from_: repr(from_)) def serialize_attribute_into( attribute_proto: onnx.AttributeProto, from_: _protocols.AttributeProtocol ) -> None: attribute_proto.name = from_.name if from_.doc_string: attribute_proto.doc_string = from_.doc_string _fill_in_value_for_attribute(attribute_proto, from_.type, from_.value) def _fill_in_value_for_attribute( attribute_proto: onnx.AttributeProto, type_: _enums.AttributeType, value: Any ) -> None: if type_ == _enums.AttributeType.INT: # value: int attribute_proto.i = value attribute_proto.type = onnx.AttributeProto.INT elif type_ == _enums.AttributeType.FLOAT: # value: float attribute_proto.f = value attribute_proto.type = onnx.AttributeProto.FLOAT elif type_ == _enums.AttributeType.STRING: # value: str attribute_proto.s = value.encode("utf-8") attribute_proto.type = onnx.AttributeProto.STRING elif type_ == _enums.AttributeType.INTS: # value: Sequence[int] attribute_proto.ints.extend(value) attribute_proto.type = onnx.AttributeProto.INTS elif type_ == _enums.AttributeType.FLOATS: # value: Sequence[float] attribute_proto.floats.extend(value) attribute_proto.type = onnx.AttributeProto.FLOATS elif type_ == _enums.AttributeType.STRINGS: # value: Sequence[str] attribute_proto.strings.extend([s.encode("utf-8") for s in value]) attribute_proto.type = onnx.AttributeProto.STRINGS elif type_ == _enums.AttributeType.TENSOR: # value: _protocols.TensorProtocol serialize_tensor_into(attribute_proto.t, value) attribute_proto.type = onnx.AttributeProto.TENSOR elif type_ == _enums.AttributeType.GRAPH: # value: _protocols.GraphProtocol serialize_graph_into(attribute_proto.g, value) attribute_proto.type = onnx.AttributeProto.GRAPH elif type_ == _enums.AttributeType.TENSORS: # value: Sequence[_protocols.TensorProtocol] for tensor in value: serialize_tensor_into(attribute_proto.tensors.add(), tensor) attribute_proto.type = onnx.AttributeProto.TENSORS elif type_ == _enums.AttributeType.GRAPHS: # value: Sequence[_protocols.GraphProtocol] for graph in value: serialize_graph_into(attribute_proto.graphs.add(), graph) attribute_proto.type = onnx.AttributeProto.GRAPHS elif type_ == _enums.AttributeType.SPARSE_TENSOR: raise NotImplementedError( f"Sparse tensors are not supported yet. {_PLEASE_CONTRIBUTE}" ) elif type_ == _enums.AttributeType.SPARSE_TENSORS: raise NotImplementedError( f"Sparse tensors are not supported yet. {_PLEASE_CONTRIBUTE}" ) elif type_ == _enums.AttributeType.TYPE_PROTO: # value: _core.TypeAndShape if value.type is not None: serialize_type_into(attribute_proto.tp, value.type) # Need to create the type _before_ writing the shape if value.shape is not None: serialize_shape_into(attribute_proto.tp, value.shape) attribute_proto.type = onnx.AttributeProto.TYPE_PROTO elif type_ == _enums.AttributeType.TYPE_PROTOS: for ir_type in value: # ir_type: _core.TypeAndShape type_proto = attribute_proto.type_protos.add() if ir_type.type is not None: serialize_type_into(type_proto, ir_type.type) # Need to create the type _before_ writing the shape so that the shape can be written to the leaf type proto if ir_type.shape is not None: serialize_shape_into(type_proto, ir_type.shape) attribute_proto.type = onnx.AttributeProto.TYPE_PROTOS else: raise TypeError(f"Unsupported attribute type: {type_}") @_capture_errors(lambda attribute_proto, from_: repr(from_)) def serialize_reference_attribute_into( attribute_proto: onnx.AttributeProto, from_: _protocols.ReferenceAttributeProtocol ) -> None: attribute_proto.name = from_.name attribute_proto.ref_attr_name = from_.ref_attr_name if from_.doc_string: attribute_proto.doc_string = from_.doc_string attribute_proto.type = typing.cast(onnx.AttributeProto.AttributeType, from_.type.value) def serialize_value(value: _protocols.ValueProtocol, *, name: str = "") -> onnx.ValueInfoProto: """Serialize a value into a ValueInfoProto. Args: value: The proto to serialize into. from_: The value to serialize. name: A custom name to set for the value info. If not provided, the name from the value will be used. """ value_info_proto = onnx.ValueInfoProto() serialize_value_into(value_info_proto, value, name=name) return value_info_proto @_capture_errors(lambda value_info_proto, from_: repr(from_)) def serialize_value_into( value_info_proto: onnx.ValueInfoProto, from_: _protocols.ValueProtocol, *, name: str = "", ) -> None: """Serialize a value into a ValueInfoProto. Args: value_info_proto: The proto to serialize into. from_: The value to serialize. name: A custom name to set for the value info. If not provided, the name from the value will be used. """ if name: value_info_proto.name = name else: value_info_proto.name = from_.name if from_.metadata_props: _serialize_metadata_props_into(value_info_proto.metadata_props, from_.metadata_props) if from_.type is not None: serialize_type_into(value_info_proto.type, from_.type) # Need to create the type _before_ writing the shape so that the shape can be written to the leaf type proto if from_.shape is not None: serialize_shape_into(value_info_proto.type, from_.shape) if from_.doc_string: value_info_proto.doc_string = from_.doc_string @_capture_errors(lambda type_proto, from_: repr(from_)) def serialize_type_into(type_proto: onnx.TypeProto, from_: _protocols.TypeProtocol) -> None: if from_.denotation: type_proto.denotation = from_.denotation if isinstance(from_, _core.TensorType): tensor_type_proto = type_proto.tensor_type tensor_type_proto.elem_type = from_.dtype.value elif isinstance(from_, _core.SparseTensorType): sparse_tensor_type_proto = type_proto.sparse_tensor_type sparse_tensor_type_proto.elem_type = from_.dtype.value elif isinstance(from_, _core.SequenceType): sequence_type_proto = type_proto.sequence_type serialize_type_into(sequence_type_proto.elem_type, from_.elem_type) elif isinstance(from_, _core.OptionalType): optional_type_proto = type_proto.optional_type serialize_type_into(optional_type_proto.elem_type, from_.elem_type) else: raise TypeError(f"Unsupported type: {from_}") def serialize_type(type_protocol: _protocols.TypeProtocol) -> onnx.TypeProto: type_proto = onnx.TypeProto() serialize_type_into(type_proto, from_=type_protocol) return type_proto @_capture_errors(lambda type_proto, from_: repr(from_)) def serialize_shape_into(type_proto: onnx.TypeProto, from_: _protocols.ShapeProtocol) -> None: value_field = type_proto.WhichOneof("value") tensor_type = getattr(type_proto, value_field) while not isinstance(tensor_type.elem_type, int): # Find the leaf type that has the shape field type_proto = tensor_type.elem_type value_field = type_proto.WhichOneof("value") tensor_type = getattr(type_proto, value_field) # When from is empty, we still need to set the shape field to an empty list by touching it tensor_type.shape.ClearField("dim") for i, dim in enumerate(from_): denotation = from_.get_denotation(i) serialize_dimension_into(tensor_type.shape.dim.add(), dim, denotation) @_capture_errors(lambda dim_proto, dim, denotation: repr(dim_proto)) def serialize_dimension_into( dim_proto: onnx.TensorShapeProto.Dimension, dim: int | _protocols.SymbolicDimProtocol, denotation: str | None = None, ) -> None: if denotation: dim_proto.denotation = denotation if isinstance(dim, int): dim_proto.dim_value = dim elif isinstance(dim, (_core.SymbolicDim, _protocols.SymbolicDimProtocol)): if dim.value is not None: # TODO(justinchuby): None is probably not a valid value for dim_param dim_proto.dim_param = str(dim.value)