onnx-ir 0.1.9__tar.gz → 0.1.10__tar.gz

{onnx_ir-0.1.9/src/onnx_ir.egg-info → onnx_ir-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-ir
-Version: 0.1.9
+Version: 0.1.10
 Summary: Efficient in-memory representation for ONNX
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
 License-Expression: Apache-2.0

{onnx_ir-0.1.9 → onnx_ir-0.1.10}/src/onnx_ir/__init__.py

@@ -168,4 +168,4 @@ def __set_module() -> None:
 
 
 __set_module()
-__version__ = "0.1.9"
+__version__ = "0.1.10"

{onnx_ir-0.1.9 → onnx_ir-0.1.10}/src/onnx_ir/_convenience/_constructors.py

@@ -224,6 +224,7 @@ def val(
     *,
     type: ir.TypeProtocol | None = None,
     const_value: ir.TensorProtocol | None = None,
+    metadata_props: dict[str, str] | None = None,
 ) -> ir.Value:
     """Create a :class:`~onnx_ir.Value` with the given name and type.
 
@@ -253,6 +254,7 @@ def val(
         type: The type of the value. Only one of dtype and type can be specified.
         const_value: The constant tensor that initializes the value. Supply this argument
             when you want to create an initializer. The type and shape can be obtained from the tensor.
+        metadata_props: The metadata properties that will be serialized to the ONNX proto.
 
     Returns:
         A Value object.
@@ -279,10 +281,11 @@ def val(
             type=const_tensor_type,
             shape=_core.Shape(const_value.shape),  # type: ignore
             const_value=const_value,
+            metadata_props=metadata_props,
         )
 
     if type is None and dtype is not None:
         type = _core.TensorType(dtype)
     if shape is not None and not isinstance(shape, _core.Shape):
         shape = _core.Shape(shape)
-    return _core.Value(name=name, type=type, shape=shape)
+    return _core.Value(name=name, type=type, shape=shape, metadata_props=metadata_props)

{onnx_ir-0.1.9 → onnx_ir-0.1.10}/src/onnx_ir/_core.py

@@ -165,6 +165,11 @@ class TensorBase(abc.ABC, _protocols.TensorProtocol, _display.PrettyPrintable):
 
     @property
     def metadata_props(self) -> dict[str, str]:
+        """The metadata properties of the tensor.
+
+        The metadata properties are used to store additional information about the tensor.
+        Unlike ``meta``, this property is serialized to the ONNX proto.
+        """
         if self._metadata_props is None:
             self._metadata_props = {}
         return self._metadata_props
@@ -1214,6 +1219,12 @@ class Shape(_protocols.ShapeProtocol, _display.PrettyPrintable):
 
     Use :meth:`get_denotation` and :meth:`set_denotation` to access and modify the denotations.
 
+    .. note::
+        Two shapes can be compared for equality. Be careful when comparing shapes with
+        unknown dimensions (``None``), as they may not be considered semantically equal
+        even if all dimensions are the same. You can use :meth:`has_unknown_dim` to
+        check if a shape has any unknown dimensions.
+
     Example::
 
         >>> import onnx_ir as ir
@@ -1422,6 +1433,29 @@ class Shape(_protocols.ShapeProtocol, _display.PrettyPrintable):
             return not self.is_static()
         return not self.is_static(dim)
 
+    def is_unknown_dim(self, dim: int) -> bool:
+        """Return True if the dimension is unknown (None).
+
+        A dynamic dimension without a symbolic name is considered unknown.
+
+        .. versionadded:: 0.1.10
+
+        Args:
+            dim: The index of the dimension.
+        """
+        dim_obj = self._dims[dim]
+        return isinstance(dim_obj, SymbolicDim) and dim_obj.value is None
+
+    def has_unknown_dim(self) -> bool:
+        """Return True if any dimension is unknown (None).
+
+        You can use :meth:`is_unknown_dim` to check if a specific dimension is unknown.
+
+        .. versionadded:: 0.1.10
+        """
+        # We can use "in" directly because SymbolicDim implements __eq__ with None
+        return None in self._dims
+
 
 def _quoted(string: str) -> str:
     """Return a quoted string.
@@ -2022,9 +2056,18 @@ class Value(_protocols.ValueProtocol, _display.PrettyPrintable):
         type: _protocols.TypeProtocol | None = None,
         doc_string: str | None = None,
         const_value: _protocols.TensorProtocol | None = None,
+        metadata_props: dict[str, str] | None = None,
     ) -> None:
         """Initialize a value.
 
+        When assigning a name to the value, the name of the backing `const_value` (Tensor)
+        will also be updated. If the value is an initializer of a graph, the initializers
+        dictionary of the graph will also be updated.
+
+        .. versionchanged:: 0.1.10
+            Assigning a name to the value will also update the graph initializer entry
+            if the value is an initializer of a graph.
+
         Args:
             producer: The node that produces the value.
                 It can be ``None`` when the value is initialized first than its producer.
@@ -2034,11 +2077,12 @@ class Value(_protocols.ValueProtocol, _display.PrettyPrintable):
             type: The type of the value.
             doc_string: The documentation string.
             const_value: The constant tensor if the value is constant.
+            metadata_props: Metadata that will be serialized to the ONNX file.
         """
         self._producer: Node | None = producer
         self._index: int | None = index
         self._metadata: _metadata.MetadataStore | None = None
-        self._metadata_props: dict[str, str] | None = None
+        self._metadata_props: dict[str, str] | None = metadata_props
 
         self._name: str | None = name
         self._shape: Shape | None = shape
@@ -2172,7 +2216,23 @@ class Value(_protocols.ValueProtocol, _display.PrettyPrintable):
     def name(self, value: str | None) -> None:
         if self._const_value is not None:
             self._const_value.name = value
+        old_name = self._name
         self._name = value
+        if self.is_initializer():
+            if value is None:
+                raise ValueError(
+                    "Initializer value cannot have name set to None. Please pop() the value from initializers first"
+                )
+            # Rename the initializer entry in the graph
+            graph = self._graph
+            assert graph is not None
+            assert old_name is not None
+            if value in graph.initializers and graph.initializers[value] is not self:
+                raise ValueError(
+                    f"Cannot rename initializer to '{value}': an initializer with that name already exists."
+                )
+            graph.initializers.pop(old_name)
+            graph.initializers[value] = self
 
     @property
     def type(self) -> _protocols.TypeProtocol | None:
@@ -2226,9 +2286,16 @@ class Value(_protocols.ValueProtocol, _display.PrettyPrintable):
     def const_value(
         self,
     ) -> _protocols.TensorProtocol | None:
-        """A concrete value.
+        """The backing constant tensor for the value.
+
+        If the ``Value`` has a ``const_value`` and is part of a graph initializers
+        dictionary, the value is an initialized value. Its ``const_value``
+        will appear as an ``initializer`` in the GraphProto when serialized.
 
-        The value can be backed by different raw data types, such as numpy arrays.
+        If the ``Value`` is not part of a graph initializers dictionary, the ``const_value``
+        field will be ignored during serialization.
+
+        ``const_value`` can be backed by different raw data types, such as numpy arrays.
         The only guarantee is that it conforms TensorProtocol.
         """
         return self._const_value
@@ -2258,6 +2325,11 @@ class Value(_protocols.ValueProtocol, _display.PrettyPrintable):
 
     @property
     def metadata_props(self) -> dict[str, str]:
+        """The metadata properties of the value.
+
+        The metadata properties are used to store additional information about the value.
+        Unlike ``meta``, this property is serialized to the ONNX proto.
+        """
         if self._metadata_props is None:
             self._metadata_props = {}
         return self._metadata_props
@@ -2805,6 +2877,11 @@ class Graph(_protocols.GraphProtocol, Sequence[Node], _display.PrettyPrintable):
 
     @property
     def metadata_props(self) -> dict[str, str]:
+        """The metadata properties of the graph.
+
+        The metadata properties are used to store additional information about the graph.
+        Unlike ``meta``, this property is serialized to the ONNX proto.
+        """
         if self._metadata_props is None:
             self._metadata_props = {}
         return self._metadata_props
@@ -3057,6 +3134,11 @@ class Model(_protocols.ModelProtocol, _display.PrettyPrintable):
 
     @property
     def metadata_props(self) -> dict[str, str]:
+        """The metadata properties of the model.
+
+        The metadata properties are used to store additional information about the model.
+        Unlike ``meta``, this property is serialized to the ONNX proto.
+        """
         if self._metadata_props is None:
             self._metadata_props = {}
         return self._metadata_props
@@ -3250,6 +3332,11 @@ class Function(_protocols.FunctionProtocol, Sequence[Node], _display.PrettyPrint
 
     @property
     def metadata_props(self) -> dict[str, str]:
+        """The metadata properties of the function.
+
+        The metadata properties are used to store additional information about the function.
+        Unlike ``meta``, this property is serialized to the ONNX proto.
+        """
         return self._graph.metadata_props
 
     def all_nodes(self) -> Iterator[Node]:

{onnx_ir-0.1.9 → onnx_ir-0.1.10}/src/onnx_ir/passes/common/constant_manipulation.py

@@ -69,7 +69,12 @@ class LiftConstantsToInitializersPass(ir.passes.InPlacePass):
                 shape=tensor.shape,  # type: ignore[arg-type]
                 type=ir.TensorType(tensor.dtype),
                 const_value=tensor,
+                # Preserve metadata from Constant value into the onnx model
+                metadata_props=node.outputs[0].metadata_props.copy(),
             )
+            # Preserve value meta from the Constant output for intermediate analysis
+            initializer.meta.update(node.outputs[0].meta)
+
             assert node.graph is not None
             node.graph.register_initializer(initializer)
             # Replace the constant node with the initializer

{onnx_ir-0.1.9 → onnx_ir-0.1.10}/src/onnx_ir/passes/common/naming.py

@@ -193,14 +193,8 @@ class NameFixPass(ir.passes.InPlacePass):
         if not value.name:
             modified = self._assign_value_name(value, used_value_names, value_counter)
         else:
-            old_name = value.name
             modified = self._fix_duplicate_value_name(value, used_value_names, value_counter)
-            if modified:
-                assert value.graph is not None
-                if value.is_initializer():
-                    value.graph.initializers.pop(old_name)
-                    # Add the initializer back with the new name
-                    value.graph.initializers.add(value)
+            # initializers dictionary is updated automatically when the Value is renamed
 
         # Record the final name for this value
         assert value.name is not None

{onnx_ir-0.1.9 → onnx_ir-0.1.10}/src/onnx_ir/serde.py

@@ -709,8 +709,7 @@ def _deserialize_graph(
         annotation.tensor_name: annotation for annotation in proto.quantization_annotation
     }
 
-    # Create values for initializers and inputs
-    initializer_tensors = [deserialize_tensor(tensor) for tensor in proto.initializer]
+    # 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)
@@ -725,6 +724,11 @@ def _deserialize_graph(
     # 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
@@ -750,6 +754,8 @@ def _deserialize_graph(
                 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
@@ -757,9 +763,6 @@ def _deserialize_graph(
             values[initializer_name] = initializer_value
         initializer_values.append(initializer_value)
 
-    # 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}
-
     # 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
@@ -1390,7 +1393,12 @@ def _should_create_value_info_for_value(value: _protocols.ValueProtocol) -> bool
         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:
+    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)
@@ -1967,11 +1975,26 @@ def serialize_type(type_protocol: _protocols.TypeProtocol) -> onnx.TypeProto:
 @_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")
@@ -1992,5 +2015,8 @@ def serialize_dimension_into(
         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)
+        # 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.

{onnx_ir-0.1.9 → onnx_ir-0.1.10/src/onnx_ir.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-ir
-Version: 0.1.9
+Version: 0.1.10
 Summary: Efficient in-memory representation for ONNX
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
 License-Expression: Apache-2.0