onnx-ir 0.1.15__py3-none-any.whl

onnx_ir/serde.py

@@ -0,0 +1,2043 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""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
+import typing
+
+__all__ = [
+    # Tensors
+    "TensorProtoTensor",
+    # Deserialization
+    "from_proto",
+    "from_onnx_text",
+    "deserialize_attribute",
+    "deserialize_dimension",
+    "deserialize_function",
+    "deserialize_graph",
+    "deserialize_metadata_props",
+    "deserialize_model",
+    "deserialize_node",
+    "deserialize_opset_import",
+    "deserialize_tensor",
+    "deserialize_tensor_shape",
+    "deserialize_type_proto_for_shape",
+    "deserialize_type_proto_for_type",
+    "deserialize_value_info_proto",
+    # Serialization
+    "to_proto",
+    "to_onnx_text",
+    "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_reference_attribute",
+    "serialize_tensor_into",
+    "serialize_tensor",
+    "serialize_type_into",
+    "serialize_type",
+    "serialize_value_into",
+    "serialize_value",
+    "SerdeError",
+]
+
+import collections
+import logging
+import os
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any, Callable
+
+import numpy as np
+import onnx  # noqa: TID251
+import onnx.external_data_helper  # noqa: TID251
+
+from onnx_ir import _convenience, _core, _enums, _protocols, _type_casting
+
+if typing.TYPE_CHECKING:
+    import google.protobuf.internal.containers as proto_containers
+
+logger = logging.getLogger(__name__)
+
+_PLEASE_CONTRIBUTE = "Please contribute by creating a PR at https://github.com/onnx/onnx-ir."
+_FUNCTION_VALUE_INFO_SUPPORTED_VERSION = (
+    10  # ONNX IR version where value info in functions was introduced
+)
+_QUANT_PARAMETER_TENSOR_NAMES_FIELD = "quant_parameter_tensor_names"
+_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("<")
+
+
+@typing.overload
+def from_proto(proto: onnx.ModelProto) -> _core.Model: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.GraphProto) -> _core.Graph: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.NodeProto) -> _core.Node: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.TensorProto) -> _protocols.TensorProtocol: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.AttributeProto) -> _core.Attr: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.ValueInfoProto) -> _core.Value: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.TypeProto) -> _core.TypeAndShape: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.FunctionProto) -> _core.Function: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: onnx.TensorShapeProto) -> _core.Shape: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(  # type: ignore[overload-overlap]
+    proto: onnx.TensorShapeProto.Dimension,
+) -> tuple[int | _core.SymbolicDim, str | None]: ...
+@typing.overload
+def from_proto(proto: Sequence[onnx.OperatorSetIdProto]) -> dict[str, int]: ...  # type: ignore[overload-overlap]
+@typing.overload
+def from_proto(proto: Sequence[onnx.StringStringEntryProto]) -> dict[str, str]: ...  # type: ignore[overload-overlap]
+
+
+def from_proto(proto: object) -> object:
+    """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)
+    if isinstance(proto, onnx.TensorShapeProto):
+        return deserialize_tensor_shape(proto)
+    if isinstance(proto, onnx.TensorShapeProto.Dimension):
+        return deserialize_dimension(proto)
+    if isinstance(proto, Sequence) and all(
+        isinstance(p, onnx.OperatorSetIdProto) for p in proto
+    ):
+        return deserialize_opset_import(proto)
+    if isinstance(proto, Sequence) and all(
+        isinstance(p, onnx.StringStringEntryProto) for p in proto
+    ):
+        return deserialize_metadata_props(proto)
+    raise NotImplementedError(
+        f"Deserialization of {type(proto)} in from_proto is not implemented. "
+        "Use a specific ir.serde.deserialize* function instead."
+    )
+
+
+def from_onnx_text(
+    model_text: str,
+    /,
+    initializers: Iterable[_protocols.TensorProtocol] | None = None,
+) -> _core.Model:
+    """Convert the ONNX textual representation to an IR model.
+
+    Read more about the textual representation at: https://onnx.ai/onnx/repo-docs/Syntax.html
+
+    .. versionchanged:: 0.1.2
+        Added the ``initializers`` argument.
+
+    Args:
+        model_text: The ONNX textual representation of the model.
+        initializers: Tensors to be added as initializers. If provided, these tensors
+            will be added to the model as initializers. If a name does not exist in the model,
+            a ValueError will be raised.
+
+    Returns:
+        The IR model corresponding to the ONNX textual representation.
+
+    Raises:
+        ValueError: If a tensor name in `initializers` does not match any value in the model.
+    """
+    proto = onnx.parser.parse_model(model_text)
+    model = deserialize_model(proto)
+    values = _convenience.create_value_mapping(model.graph)
+    if initializers:
+        # Add initializers to the model
+        for tensor in initializers:
+            name = tensor.name
+            if not name:
+                raise ValueError(
+                    "Initializer tensor must have a name. "
+                    f"Please provide a name for the initializer: {tensor}"
+                )
+            if name not in values:
+                raise ValueError(f"Value '{name}' does not exist in model.")
+            initializer = values[name]
+            initializer.const_value = tensor
+            model.graph.register_initializer(initializer)
+    return model
+
+
+def to_onnx_text(
+    model: _protocols.ModelProtocol, /, exclude_initializers: bool = False
+) -> str:
+    """Convert the IR model to the ONNX textual representation.
+
+    .. versionadded:: 0.1.2
+
+    Args:
+        model: The IR model to convert.
+        exclude_initializers: If True, the initializers will not be included in the output.
+
+    Returns:
+        The ONNX textual representation of the model.
+    """
+    proto = serialize_model(model)
+    if exclude_initializers:
+        del proto.graph.initializer[:]
+    text = onnx.printer.to_text(proto)
+    return text
+
+
+@typing.overload
+def to_proto(ir_object: _protocols.ModelProtocol) -> onnx.ModelProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.GraphProtocol) -> onnx.GraphProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.NodeProtocol) -> onnx.NodeProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.TensorProtocol) -> onnx.TensorProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.AttributeProtocol) -> onnx.AttributeProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.ReferenceAttributeProtocol) -> onnx.AttributeProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.ValueProtocol) -> onnx.ValueInfoProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.TypeProtocol) -> onnx.TypeProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.FunctionProtocol) -> onnx.FunctionProto: ...  # type: ignore[overload-overlap]
+@typing.overload
+def to_proto(ir_object: _protocols.GraphViewProtocol) -> onnx.GraphProto: ...  # type: ignore[overload-overlap]
+
+
+def to_proto(ir_object: object) -> object:
+    """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) and not ir_object.is_ref():
+        return serialize_attribute(ir_object)
+    if isinstance(ir_object, _protocols.ReferenceAttributeProtocol):
+        assert ir_object.is_ref()
+        return serialize_reference_attribute(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."""
+
+    __slots__ = ("_proto",)
+
+    def __init__(self, proto: onnx.TensorProto) -> None:
+        super().__init__(metadata_props=deserialize_metadata_props(proto.metadata_props))
+        self._proto = proto
+
+    @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  # type: ignore[misc]
+    def doc_string(self) -> str:
+        return self._proto.doc_string
+
+    @property
+    def raw(self) -> onnx.TensorProto:
+        return self._proto
+
+    def __repr__(self) -> str:
+        if self.size <= 10:
+            tensor_lines = repr(self.numpy()).split("\n")
+            tensor_text = " ".join(line.strip() for line in tensor_lines)
+            return f"{self._repr_base()}({tensor_text}, name={self.name!r})"
+        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__()
+
+    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:`onnx_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."
+            )
+
+        shape = self._proto.dims
+
+        if self._proto.HasField("raw_data"):
+            if dtype.bitwidth == 4:
+                return _type_casting.unpack_4bitx2(
+                    np.frombuffer(self._proto.raw_data, dtype=np.uint8), shape
+                ).view(dtype.numpy())
+            if dtype.bitwidth == 2:
+                return _type_casting.unpack_2bitx4(
+                    np.frombuffer(self._proto.raw_data, dtype=np.uint8), shape
+                ).view(dtype.numpy())
+            return np.frombuffer(
+                self._proto.raw_data, dtype=dtype.numpy().newbyteorder("<")
+            ).reshape(shape)
+        if dtype == _enums.DataType.STRING:
+            return np.array(self._proto.string_data).reshape(shape)
+        if self._proto.int32_data:
+            assert dtype in {
+                _enums.DataType.BFLOAT16,
+                _enums.DataType.BOOL,
+                _enums.DataType.FLOAT16,
+                _enums.DataType.FLOAT4E2M1,
+                _enums.DataType.FLOAT8E4M3FN,
+                _enums.DataType.FLOAT8E4M3FNUZ,
+                _enums.DataType.FLOAT8E5M2,
+                _enums.DataType.FLOAT8E5M2FNUZ,
+                _enums.DataType.FLOAT8E8M0,
+                _enums.DataType.INT16,
+                _enums.DataType.INT32,
+                _enums.DataType.INT2,
+                _enums.DataType.INT4,
+                _enums.DataType.INT8,
+                _enums.DataType.UINT16,
+                _enums.DataType.UINT2,
+                _enums.DataType.UINT4,
+                _enums.DataType.UINT8,
+            }, f"Unsupported dtype {dtype} for int32_data"
+            array = np.array(self._proto.int32_data, dtype=_little_endian_dtype(np.int32))
+            if dtype.bitwidth == 32:
+                return array.reshape(shape)
+            if dtype.bitwidth == 16:
+                # Reinterpret the int32 as float16 or bfloat16
+                return array.astype(np.uint16).view(dtype.numpy()).reshape(shape)
+            if dtype.bitwidth == 8:
+                return array.astype(np.uint8).view(dtype.numpy()).reshape(shape)
+            if dtype.bitwidth == 4:
+                return _type_casting.unpack_4bitx2(array.astype(np.uint8), shape).view(
+                    dtype.numpy()
+                )
+            if dtype.bitwidth == 2:
+                return _type_casting.unpack_2bitx4(array.astype(np.uint8), shape).view(
+                    dtype.numpy()
+                )
+            raise ValueError(
+                f"Unsupported dtype {dtype} for int32_data with bitwidth {dtype.bitwidth}"
+            )
+        if self._proto.int64_data:
+            assert dtype in {
+                _enums.DataType.INT64,
+            }, f"Unsupported dtype {dtype} for int64_data"
+            return np.array(
+                self._proto.int64_data, dtype=_little_endian_dtype(np.int64)
+            ).reshape(shape)
+        if self._proto.uint64_data:
+            assert dtype in {
+                _enums.DataType.UINT64,
+                _enums.DataType.UINT32,
+            }, f"Unsupported dtype {dtype} for uint64_data"
+            array = np.array(self._proto.uint64_data, dtype=_little_endian_dtype(np.uint64))
+            if dtype == _enums.DataType.UINT32:
+                return array.astype(np.uint32).reshape(shape)
+            return array.reshape(shape)
+        if self._proto.float_data:
+            assert dtype in {
+                _enums.DataType.FLOAT,
+                _enums.DataType.COMPLEX64,
+            }, f"Unsupported dtype {dtype} for float_data"
+            array = np.array(self._proto.float_data, dtype=_little_endian_dtype(np.float32))
+            if dtype == _enums.DataType.COMPLEX64:
+                return array.view(np.complex64).reshape(shape)
+            return array.reshape(shape)
+        if self._proto.double_data:
+            assert dtype in {
+                _enums.DataType.DOUBLE,
+                _enums.DataType.COMPLEX128,
+            }, f"Unsupported dtype {dtype} for double_data"
+            array = np.array(self._proto.double_data, dtype=_little_endian_dtype(np.float64))
+            if dtype == _enums.DataType.COMPLEX128:
+                return array.view(np.complex128).reshape(shape)
+            return array.reshape(shape)
+
+        # Empty tensor. We return a size 0 array with the correct shape
+        return np.zeros(shape, dtype=dtype.numpy())
+
+    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.FLOAT8E8M0,
+                _enums.DataType.INT2,
+                _enums.DataType.INT4,
+                _enums.DataType.UINT2,
+                _enums.DataType.UINT4,
+                _enums.DataType.FLOAT4E2M1,
+            }:
+                # uint2, uint4, int2 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""
+
+
+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]:
+    """Deserialize a sequence of OperatorSetIdProto to opset imports mapping.
+
+    Args:
+        protos: The sequence of ONNX OperatorSetIdProto objects.
+
+    Returns:
+        A dictionary mapping domain strings to version integers.
+    """
+    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:
+    """Deserialize an ONNX ModelProto into an IR Model.
+
+    Args:
+        proto: The ONNX ModelProto to deserialize.
+
+    Returns:
+        An IR Model object representing the ONNX 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,
+        metadata_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.
+
+    .. versionadded:: 0.1.3
+        Support for `quantization_annotation` is added.
+    """
+    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.
+    """
+    # Process TensorAnnotation for quantization
+    quantization_annotations = {
+        annotation.tensor_name: annotation for annotation in proto.quantization_annotation
+    }
+
+    # Create values for inputs
+    inputs = [_core.Value(name=info.name) for info in proto.input]
+    for info, value in zip(proto.input, inputs):
+        deserialize_value_info_proto(info, value)
+
+        # Add TensorAnnotation for inputs if they exist
+        if value.name in quantization_annotations:
+            _deserialize_quantization_annotation(quantization_annotations[value.name], 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]
+
+    # Enter the graph scope by pushing the values for this scope to the stack
+    scoped_values.append(values)
+
+    # Build the value info dictionary to allow for quick lookup for this graph scope
+    value_info = {info.name: info for info in proto.value_info}
+
+    # Create values for initializers
+    initializer_tensors = [deserialize_tensor(tensor) for tensor in proto.initializer]
+    initializer_values = []
+    for i, tensor in enumerate(initializer_tensors):
+        initializer_name = tensor.name
+        if not initializer_name:
+            logger.warning(
+                "Initializer tensor must have a name but the %s-th initializer does not. Skipping this initializer.",
+                i,
+            )
+            continue
+        if initializer_name in values:
+            # The initializer is for an input
+            initializer_value = values[initializer_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=initializer_name,
+                # Include shape and type even if the shape or type is not provided as ValueInfoProto.
+                # Users expect initialized values to have shape and type information.
+                type=_core.TensorType(tensor.dtype),
+                shape=tensor.shape,  # type: ignore[arg-type]
+                const_value=tensor,
+            )
+            if initializer_name in value_info:
+                deserialize_value_info_proto(value_info[initializer_name], initializer_value)
+            if initializer_value.name in quantization_annotations:
+                _deserialize_quantization_annotation(
+                    quantization_annotations[initializer_value.name], initializer_value
+                )
+            values[initializer_name] = initializer_value
+        initializer_values.append(initializer_value)
+
+    # Declare values for all node outputs from this graph scope. This is necessary
+    # to handle the case where a node in a subgraph uses a value that is declared out
+    # of order in the outer graph. Declaring the values first allows us to find the
+    # values later when deserializing the nodes in subgraphs.
+    for node in proto.node:
+        _declare_node_outputs(
+            node,
+            values,
+            value_info=value_info,
+            quantization_annotations=quantization_annotations,
+        )
+
+    # Deserialize nodes with all known values
+    nodes = [
+        _deserialize_node(node, scoped_values, value_info, quantization_annotations)
+        for node in proto.node
+    ]
+
+    outputs = []
+    for info in proto.output:
+        # Fill in values for graph outputs
+        output_name = info.name
+        if output_name not in values:
+            # Handle (invalid) graph outputs that do not have any producers
+            logger.warning(
+                "Output '%s' is not produced by any node. The graph has an invalid output",
+                output_name,
+            )
+            value = _core.Value(name=output_name)
+        else:
+            # A valid, normal graph output
+            value = values[output_name]
+        # Fill in shape/type information
+        deserialize_value_info_proto(info, value)
+        outputs.append(value)
+
+    # Exit the graph scope by popping the values for this scope from the stack
+    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),
+    )
+
+
+def _declare_node_outputs(
+    proto: onnx.NodeProto,
+    current_value_scope: dict[str, _core.Value],
+    value_info: dict[str, onnx.ValueInfoProto],
+    quantization_annotations: dict[str, onnx.TensorAnnotation],
+) -> None:
+    """Declare outputs for a node in the current graph scope.
+
+    This is necessary to handle the case where a node in a subgraph uses a value that is declared
+    out of order in the outer graph. Declaring the values first allows us to find the values later
+    when deserializing the nodes in subgraphs.
+
+    Args:
+        proto: The ONNX NodeProto to declare outputs for.
+        current_value_scope: The current scope of values, mapping value names to their corresponding Value objects.
+        value_info: A dictionary mapping value names to their corresponding ValueInfoProto.
+        quantization_annotations: A dictionary mapping tensor names to their corresponding TensorAnnotation.
+
+    Raises:
+        ValueError: If an output name is redeclared in the current graph scope.
+    """
+    for output_name in proto.output:
+        if output_name == "":
+            continue
+        if output_name in current_value_scope:
+            raise ValueError(
+                f"Output '{output_name}' is redeclared in the current graph scope. "
+                f"Original declaration {current_value_scope[output_name]}. "
+                f"New declaration: by operator '{proto.op_type}' of node '{proto.name}'. "
+                "The model is invalid"
+            )
+
+        # Create the value and add it to the current scope.
+        value = _core.Value(name=output_name)
+        current_value_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,
+            )
+        if output_name in quantization_annotations:
+            _deserialize_quantization_annotation(quantization_annotations[output_name], value)
+
+
+@_capture_errors(lambda proto: proto.name)
+def deserialize_function(proto: onnx.FunctionProto) -> _core.Function:
+    """Deserialize an ONNX FunctionProto into an IR Function.
+
+    Args:
+        proto: The ONNX FunctionProto to deserialize.
+
+    Returns:
+        An IR Function object representing the ONNX function.
+    """
+    inputs = [_core.Value(name=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", [])}
+
+    for node in proto.node:
+        _declare_node_outputs(
+            node,
+            values,
+            value_info=value_info,
+            quantization_annotations={},
+        )
+
+    nodes = [
+        _deserialize_node(node, [values], value_info=value_info, quantization_annotations={})
+        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 ""
+        ),
+        metadata_props=deserialize_metadata_props(proto.metadata_props),
+    )
+    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=attributes,
+    )
+
+
+@_capture_errors(lambda proto, value: str(proto))
+def deserialize_value_info_proto(
+    proto: onnx.ValueInfoProto, value: _core.Value | None
+) -> _core.Value:
+    """Deserialize an ONNX ValueInfoProto into an IR Value.
+
+    Args:
+        proto: The ONNX ValueInfoProto to deserialize.
+        value: An existing Value to update, or None to create a new one.
+
+    Returns:
+        An IR Value object with type and shape information populated from the proto.
+    """
+    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(lambda proto, value: str(proto))
+def _deserialize_quantization_annotation(
+    proto: onnx.TensorAnnotation, value: _core.Value
+) -> None:
+    """Deserialize a quantization_annotation as TensorAnnotation into a Value.
+
+    This function is marked private because we don't expect users to call it directly.
+    """
+    value.meta[_QUANT_PARAMETER_TENSOR_NAMES_FIELD] = _deserialize_string_string_maps(
+        proto.quant_parameter_tensor_names
+    )
+
+
+@_capture_errors(str)
+def deserialize_tensor_shape(proto: onnx.TensorShapeProto) -> _core.Shape:
+    """Deserialize an ONNX TensorShapeProto into an IR Shape.
+
+    Args:
+        proto: The ONNX TensorShapeProto to deserialize.
+
+    Returns:
+        An IR Shape object representing the tensor shape.
+    """
+    # This logic handles when the shape is [] as well
+    dim_protos = 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)
+
+
+@_capture_errors(str)
+def deserialize_type_proto_for_shape(proto: onnx.TypeProto) -> _core.Shape | None:
+    """Extract and deserialize shape information from an ONNX TypeProto.
+
+    Args:
+        proto: The ONNX TypeProto to extract shape from.
+
+    Returns:
+        An IR Shape object if shape information is present, None otherwise.
+    """
+    if proto.HasField("tensor_type"):
+        if (shape_proto := _get_field(proto.tensor_type, "shape")) is None:
+            return None
+        return deserialize_tensor_shape(shape_proto)
+    if proto.HasField("sparse_tensor_type"):
+        if (shape_proto := _get_field(proto.sparse_tensor_type, "shape")) is None:
+            return None
+        return deserialize_tensor_shape(shape_proto)
+    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:
+    """Extract and deserialize type information from an ONNX TypeProto.
+
+    Args:
+        proto: The ONNX TypeProto to extract type from.
+
+    Returns:
+        An IR type object (TensorType, SequenceType, etc.) if type information is present, None otherwise.
+    """
+    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(
+            external_info.location,
+            offset=external_info.offset,
+            length=external_info.length,
+            dtype=_enums.DataType(proto.data_type),
+            base_dir=base_path,
+            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}
+
+
+_deserialize_string_string_maps = deserialize_metadata_props
+
+
+def deserialize_attribute(proto: onnx.AttributeProto) -> _core.Attr:
+    """Deserialize an ONNX AttributeProto into an IR Attribute.
+
+    Args:
+        proto: The ONNX AttributeProto to deserialize.
+
+    Returns:
+        An IR Attribute object representing the ONNX attribute.
+    """
+    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:
+    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:
+        try:
+            return _core.AttrString(name, proto.s.decode("utf-8"), doc_string=doc_string)
+        except UnicodeDecodeError:
+            # Even though onnx.ai/onnx/repo-docs/IR.html#attributes requires the attribute
+            # for strings to be utf-8 encoded bytes, custom ops may still store arbitrary data there
+            logger.warning(
+                "Attribute %r contains invalid UTF-8 bytes. ONNX spec requires string attributes "
+                "to be UTF-8 encoded so the model is invalid. We will skip decoding the attribute and "
+                "use the bytes as attribute value",
+                name,
+            )
+            return _core.Attr(name, type_, proto.s, 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:
+    """Deserialize an ONNX NodeProto into an IR Node.
+
+    Args:
+        proto: The ONNX NodeProto to deserialize.
+
+    Returns:
+        An IR Node object representing the ONNX node.
+    """
+    value_scope: dict[str, _core.Value] = {}
+    _declare_node_outputs(
+        proto,
+        value_scope,
+        value_info={},
+        quantization_annotations={},
+    )
+    return _deserialize_node(
+        proto, scoped_values=[value_scope], value_info={}, quantization_annotations={}
+    )
+
+
+@_capture_errors(lambda proto, scoped_values, value_info, quantization_annotations: str(proto))
+def _deserialize_node(
+    proto: onnx.NodeProto,
+    scoped_values: list[dict[str, _core.Value]],
+    value_info: dict[str, onnx.ValueInfoProto],
+    quantization_annotations: dict[str, onnx.TensorAnnotation],
+) -> _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 is invalid because the value
+            # is not declared. We will still create a new input for the node so that
+            # it can be fixed later.
+            logger.warning(
+                "Input '%s' of node '%s' (%s::%s:%s) cannot be found in any scope. "
+                "The model is invalid but we will still create a new input for the node (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)
+            if input_name in quantization_annotations:
+                _deserialize_quantization_annotation(
+                    quantization_annotations[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
+
+        # The outputs should already be declared in the current scope by _declare_node_outputs.
+        #
+        # 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]
+        assert output_name in current_scope, (
+            f"Output '{output_name}' not found in the current scope. This is unexpected"
+        )
+        value = current_scope[output_name]
+        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:
+    """Serialize an IR Model to an ONNX ModelProto.
+
+    Args:
+        model: The IR Model to serialize.
+
+    Returns:
+        The serialized ONNX ModelProto object.
+    """
+    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
+    if (
+        value.shape is None
+        and value.type is None
+        and not value.metadata_props
+        and not value.doc_string
+    ):
+        return False
+    if not value.name:
+        logger.debug("Did not serialize '%s' because its name is empty", value)
+        return False
+    return True
+
+
+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:
+            logger.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:
+                logger.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_string_string_maps(
+    string_string_entries: proto_containers.RepeatedCompositeFieldContainer[
+        onnx.StringStringEntryProto
+    ],
+    from_: Mapping[str, str],
+) -> None:
+    """Serialize a <str, str> mapping into a repeated field of string-string entries.
+
+    Args:
+        string_string_entries: The repeated field to serialize into.
+        from_: The mapping of a <str, str> mapping to serialize.
+    """
+    # Sort names for deterministic serialization
+    for key in sorted(from_):
+        string_string_entries.add(key=key, value=from_[key])
+
+
+_serialize_metadata_props_into = _serialize_string_string_maps
+
+
+def _maybe_add_quantization_annotation(
+    graph_proto: onnx.GraphProto, value: _protocols.ValueProtocol
+) -> None:
+    if quantization_annotation := value.meta.get(_QUANT_PARAMETER_TENSOR_NAMES_FIELD):
+        _serialize_tensor_annotation_into(
+            graph_proto.quantization_annotation.add(), value.name, quantization_annotation
+        )
+
+
+def _serialize_tensor_annotation_into(
+    tensor_annotation_proto: onnx.TensorAnnotation,
+    tensor_name: str,
+    quant_parameter_tensor_names: dict[str, str],
+) -> None:
+    tensor_annotation_proto.tensor_name = tensor_name
+    _serialize_string_string_maps(
+        tensor_annotation_proto.quant_parameter_tensor_names, quant_parameter_tensor_names
+    )
+
+
+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_)
+        if input_.name not in from_.initializers:
+            # Annotations for initializers will be added below to avoid double adding
+            _maybe_add_quantization_annotation(graph_proto, input_)
+    input_names = {input_.name for input_ in from_.inputs}
+    # TODO(justinchuby): Support sparse_initializer
+    for value in from_.initializers.values():
+        _maybe_add_quantization_annotation(graph_proto, value)
+        if _should_create_value_info_for_value(value) and value.name not in input_names:
+            # Serialize information about all initializers into value_info,
+            # except for those that are also graph inputs
+            serialize_value_into(graph_proto.value_info.add(), value)
+        if value.const_value is None:
+            # Skip initializers without constant values
+            logger.warning("Initializer '%s' does not have a constant value set.", value.name)
+            continue
+        # Make sure the tensor's name is the same as the value's name
+        value.const_value.name = value.name
+        serialize_tensor_into(graph_proto.initializer.add(), from_=value.const_value)
+    for node in from_:
+        serialize_node_into(graph_proto.node.add(), from_=node)
+        for node_output in node.outputs:
+            if node_output.is_graph_output():
+                # No need to serialize info for these outputs because they are handled as graph outputs
+                continue
+            _maybe_add_quantization_annotation(graph_proto, node_output)
+            if not _should_create_value_info_for_value(node_output):  # pylint: disable=no-else-continue
+                # No need to serialize value info if it is not set
+                continue
+            else:
+                serialize_value_into(graph_proto.value_info.add(), node_output)
+    for output in from_.outputs:
+        serialize_value_into(graph_proto.output.add(), from_=output)
+        _maybe_add_quantization_annotation(graph_proto, 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:
+    """Serialize an IR Node to an ONNX NodeProto.
+
+    Args:
+        node: The IR Node to serialize.
+
+    Returns:
+        The serialized ONNX NodeProto object.
+    """
+    node_proto = onnx.NodeProto()
+    serialize_node_into(node_proto, from_=node)
+    return node_proto
+
+
+def _remove_trailing_outputs(
+    outputs: Sequence[_protocols.ValueProtocol],
+) -> Sequence[_protocols.ValueProtocol]:
+    """Remove trailing outputs that have empty names.
+
+    Args:
+        outputs: The outputs to remove trailing outputs from.
+
+    Returns:
+        The outputs with trailing outputs removed.
+    """
+    for i, output in enumerate(reversed(outputs)):
+        if output.name:
+            return outputs[: len(outputs) - i]
+    return []
+
+
+@_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)
+
+    # Do not include the trailing outputs that have empty names
+    for output in _remove_trailing_outputs(from_.outputs):
+        node_proto.output.append(output.name)
+
+    for attr in from_.attributes.values():
+        if not attr.is_ref():
+            serialize_attribute_into(node_proto.attribute.add(), from_=attr)  # type: ignore[arg-type]
+        else:
+            serialize_reference_attribute_into(node_proto.attribute.add(), from_=attr)  # type: ignore[arg-type]
+
+
+def serialize_tensor(tensor: _protocols.TensorProtocol) -> onnx.TensorProto:
+    """Serialize an IR Tensor to an ONNX TensorProto.
+
+    Args:
+        tensor: The IR Tensor to serialize.
+
+    Returns:
+        The serialized ONNX TensorProto object.
+    """
+    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_.location),
+            "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:
+    """Serialize an IR Attribute to an ONNX AttributeProto.
+
+    Args:
+        attribute: The IR Attribute to serialize.
+
+    Returns:
+        The serialized ONNX AttributeProto object.
+    """
+    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
+        if type(value) is bytes:
+            # Even though onnx.ai/onnx/repo-docs/IR.html#attributes requires the attribute
+            # for strings to be utf-8 encoded bytes, custom ops may still store arbitrary data there
+            logger.warning(
+                "Value in attribute %r should be a string but is instead bytes. ONNX "
+                "spec requires string attributes to be UTF-8 encoded so the model is invalid. "
+                "We will skip encoding the attribute and use the bytes as attribute value",
+                attribute_proto.name,
+            )
+            attribute_proto.s = value
+        else:
+            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_reference_attribute(
+    attr: _protocols.ReferenceAttributeProtocol,
+) -> onnx.AttributeProto:
+    attr_proto = onnx.AttributeProto()
+    serialize_reference_attribute_into(attr_proto, attr)
+    return attr_proto
+
+
+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_, name="": 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:
+    """Serialize an IR Type to an ONNX TypeProto.
+
+    Args:
+        type_protocol: The IR Type to serialize.
+
+    Returns:
+        The serialized ONNX TypeProto object.
+    """
+    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")
+    if value_field is None:
+        # We cannot write the shape because we do not know where to write it
+        logger.warning(
+            # TODO(justinchuby): Show more context about the value when move everything to an object
+            "The value type for shape %s is not known. Please set type for the value. Skipping serialization",
+            from_,
+        )
+        return
+    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")
+        if value_field is None:
+            logger.warning(
+                # TODO(justinchuby): Show more context about the value when move everything to an object
+                "The value type for shape %s is not known. Please set type for the value. Skipping serialization",
+                from_,
+            )
+            return
+        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:
+            dim_proto.dim_param = str(dim.value)
+        # NOTE: None is a valid value for symbolic dimension:
+        # A dimension MAY have neither dim_value nor dim_param set. Such a dimension
+        # represents an unknown dimension unrelated to other unknown dimensions.
+        # Here we will just leave the dim_proto empty.