onnx-ir 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

onnx_ir/__init__.py

@@ -167,4 +167,4 @@ def __set_module() -> None:
 
 
 __set_module()
-__version__ = "0.1.2"
+__version__ = "0.1.3"

onnx_ir/_convenience/__init__.py

@@ -323,6 +323,9 @@ def create_value_mapping(graph: _core.Graph) -> dict[str, _core.Value]:
     and the first value with that name is returned. Values with empty names
     are excluded from the mapping.
 
+    .. versionchanged:: 0.1.2
+        Values from subgraphs are now included in the mapping.
+
     Args:
         graph: The graph to extract the mapping from.
 
@@ -410,6 +413,8 @@ def get_const_tensor(
     it will propagate the shape and type of the constant tensor to the value
     if `propagate_shape_type` is set to True.
 
+    .. versionadded:: 0.1.2
+
     Args:
         value: The value to get the constant tensor from.
         propagate_shape_type: If True, the shape and type of the value will be

onnx_ir/_core.py

@@ -417,6 +417,9 @@ class Tensor(TensorBase, _protocols.TensorProtocol, Generic[TArrayCompatible]):
         else:
             self._shape = shape
             self._shape.freeze()
+        if isinstance(value, np.generic):
+            # Turn numpy scalar into a numpy array
+            value = np.array(value)  # type: ignore[assignment]
         if dtype is None:
             if isinstance(value, np.ndarray):
                 self._dtype = _enums.DataType.from_numpy(value.dtype)
@@ -964,7 +967,10 @@ class LazyTensor(TensorBase, _protocols.TensorProtocol):  # pylint: disable=too-
 
 
 class PackedTensor(TensorBase, _protocols.TensorProtocol, Generic[TArrayCompatible]):  # pylint: disable=too-many-ancestors
-    """A tensor that stores 4bit datatypes in packed format."""
+    """A tensor that stores 4bit datatypes in packed format.
+
+    .. versionadded:: 0.1.2
+    """
 
     __slots__ = (
         "_dtype",
@@ -2335,6 +2341,12 @@ class Graph(_protocols.GraphProtocol, Sequence[Node], _display.PrettyPrintable):
     seen as a Sequence of nodes and should be used as such. For example, to obtain
     all nodes as a list, call ``list(graph)``.
 
+    .. versionchanged:: 0.1.1
+        Values with non-none producers will be rejected as graph inputs or initializers.
+
+    .. versionadded:: 0.1.1
+        Added ``add`` method to initializers and attributes.
+
     Attributes:
         name: The name of the graph.
         inputs: The input values of the graph.
@@ -2545,12 +2557,17 @@ class Graph(_protocols.GraphProtocol, Sequence[Node], _display.PrettyPrintable):
         Consider using
         :class:`onnx_ir.traversal.RecursiveGraphIterator` for more advanced
         traversals on nodes.
+
+        .. versionadded:: 0.1.2
         """
         # NOTE: This is a method specific to Graph, not required by the protocol unless proven
         return onnx_ir.traversal.RecursiveGraphIterator(self)
 
     def subgraphs(self) -> Iterator[Graph]:
-        """Get all subgraphs in the graph in O(#nodes + #attributes) time."""
+        """Get all subgraphs in the graph in O(#nodes + #attributes) time.
+
+        .. versionadded:: 0.1.2
+        """
         seen_graphs: set[Graph] = set()
         for node in onnx_ir.traversal.RecursiveGraphIterator(self):
             graph = node.graph
@@ -3216,12 +3233,17 @@ class Function(_protocols.FunctionProtocol, Sequence[Node], _display.PrettyPrint
         Consider using
         :class:`onnx_ir.traversal.RecursiveGraphIterator` for more advanced
         traversals on nodes.
+
+        .. versionadded:: 0.1.2
         """
         # NOTE: This is a method specific to Graph, not required by the protocol unless proven
         return onnx_ir.traversal.RecursiveGraphIterator(self)
 
     def subgraphs(self) -> Iterator[Graph]:
-        """Get all subgraphs in the function in O(#nodes + #attributes) time."""
+        """Get all subgraphs in the function in O(#nodes + #attributes) time.
+
+        .. versionadded:: 0.1.2
+        """
         seen_graphs: set[Graph] = set()
         for node in onnx_ir.traversal.RecursiveGraphIterator(self):
             graph = node.graph

onnx_ir/_enums.py

@@ -120,6 +120,8 @@ class DataType(enum.IntEnum):
     def bitwidth(self) -> int:
         """Returns the bit width of the data type.
 
+        .. versionadded:: 0.1.2
+
         Raises:
             TypeError: If the data type is not supported.
         """

onnx_ir/passes/common/__init__.py

@@ -6,6 +6,7 @@ __all__ = [
     "CheckerPass",
     "ClearMetadataAndDocStringPass",
     "CommonSubexpressionEliminationPass",
+    "DeduplicateInitializersPass",
     "InlinePass",
     "LiftConstantsToInitializersPass",
     "LiftSubgraphInitializersToMainGraphPass",
@@ -29,6 +30,9 @@ from onnx_ir.passes.common.constant_manipulation import (
     LiftSubgraphInitializersToMainGraphPass,
     RemoveInitializersFromInputsPass,
 )
+from onnx_ir.passes.common.initializer_deduplication import (
+    DeduplicateInitializersPass,
+)
 from onnx_ir.passes.common.inliner import InlinePass
 from onnx_ir.passes.common.onnx_checker import CheckerPass
 from onnx_ir.passes.common.shape_inference import ShapeInferencePass

onnx_ir/passes/common/common_subexpression_elimination.py

@@ -17,93 +17,122 @@ logger = logging.getLogger(__name__)
 
 
 class CommonSubexpressionEliminationPass(ir.passes.InPlacePass):
-    """Eliminate common subexpression in ONNX graphs."""
+    """Eliminate common subexpression in ONNX graphs.
+
+    .. versionadded:: 0.1.1
+
+    .. versionchanged:: 0.1.3
+        Constant nodes with values smaller than ``size_limit`` will be CSE'd.
+
+    Attributes:
+        size_limit: The maximum size of the tensor to be csed. If the tensor contains
+            number of elements larger than size_limit, it will not be cse'd. Default is 10.
+
+    """
+
+    def __init__(self, size_limit: int = 10):
+        """Initialize the CommonSubexpressionEliminationPass."""
+        super().__init__()
+        self.size_limit = size_limit
 
     def call(self, model: ir.Model) -> ir.passes.PassResult:
         """Return the same ir.Model but with CSE applied to the graph."""
-        modified = False
         graph = model.graph
-
-        modified = _eliminate_common_subexpression(graph, modified)
+        modified = self._eliminate_common_subexpression(graph)
 
         return ir.passes.PassResult(
             model,
             modified=modified,
         )
 
-
-def _eliminate_common_subexpression(graph: ir.Graph, modified: bool) -> bool:
-    """Eliminate common subexpression in ONNX graphs."""
-    # node to node identifier, length of outputs, inputs, and attributes
-    existing_node_info_to_the_node: dict[
-        tuple[
-            ir.OperatorIdentifier,
-            int,  # len(outputs)
-            tuple[int, ...],  # input ids
-            tuple[tuple[str, object], ...],  # attributes
-        ],
-        ir.Node,
-    ] = {}
-
-    for node in graph:
-        # Skip control flow ops like Loop and If.
-        control_flow_op: bool = False
-        # Use equality to check if the node is a common subexpression.
-        attributes = {}
-        for k, v in node.attributes.items():
-            # TODO(exporter team): CSE subgraphs.
-            # NOTE: control flow ops like Loop and If won't be CSEd
-            # because attribute: graph won't match.
-            if v.type in (ir.AttributeType.GRAPH, ir.AttributeType.GRAPHS):
-                control_flow_op = True
+    def _eliminate_common_subexpression(self, graph: ir.Graph) -> bool:
+        """Eliminate common subexpression in ONNX graphs."""
+        modified: bool = False
+        # node to node identifier, length of outputs, inputs, and attributes
+        existing_node_info_to_the_node: dict[
+            tuple[
+                ir.OperatorIdentifier,
+                int,  # len(outputs)
+                tuple[int, ...],  # input ids
+                tuple[tuple[str, object], ...],  # attributes
+            ],
+            ir.Node,
+        ] = {}
+
+        for node in graph:
+            # Skip control flow ops like Loop and If.
+            control_flow_op: bool = False
+            # Skip large tensors to avoid cse weights and bias.
+            large_tensor: bool = False
+            # Use equality to check if the node is a common subexpression.
+            attributes = {}
+            for k, v in node.attributes.items():
+                # TODO(exporter team): CSE subgraphs.
+                # NOTE: control flow ops like Loop and If won't be CSEd
+                # because attribute: graph won't match.
+                if v.type in (ir.AttributeType.GRAPH, ir.AttributeType.GRAPHS):
+                    control_flow_op = True
+                    break
+                # The attribute value could be directly taken from the original
+                # protobuf, so we need to make a copy of it.
+                value = v.value
+                if v.type in (
+                    ir.AttributeType.INTS,
+                    ir.AttributeType.FLOATS,
+                    ir.AttributeType.STRINGS,
+                ):
+                    # For INT, FLOAT and STRING attributes, we convert them to tuples
+                    # to ensure they are hashable.
+                    value = tuple(value)
+                elif v.type is ir.AttributeType.TENSOR:
+                    if value.size > self.size_limit:
+                        # If the tensor is larger than the size limit, we skip it.
+                        large_tensor = True
+                        break
+                    np_value = value.numpy()
+
+                    value = (np_value.shape, str(np_value.dtype), np_value.tobytes())
+                attributes[k] = value
+
+            if control_flow_op:
+                # If the node is a control flow op, we skip it.
                 logger.debug("Skipping control flow op %s", node)
-            # The attribute value could be directly taken from the original
-            # protobuf, so we need to make a copy of it.
-            value = v.value
-            if v.type in (
-                ir.AttributeType.INTS,
-                ir.AttributeType.FLOATS,
-                ir.AttributeType.STRINGS,
-            ):
-                # For INT, FLOAT and STRING attributes, we convert them to tuples
-                # to ensure they are hashable.
-                value = tuple(value)
-            attributes[k] = value
-
-        if control_flow_op:
-            # If the node is a control flow op, we skip it.
-            logger.debug("Skipping control flow op %s", node)
-            continue
-
-        if _is_non_deterministic_op(node):
-            # If the node is a non-deterministic op, we skip it.
-            logger.debug("Skipping non-deterministic op %s", node)
-            continue
-
-        node_info = (
-            node.op_identifier(),
-            len(node.outputs),
-            tuple(id(input) for input in node.inputs),
-            tuple(sorted(attributes.items())),
-        )
-        # Check if the node is a common subexpression.
-        if node_info in existing_node_info_to_the_node:
-            # If it is, this node has an existing node with the same
-            # operator, number of outputs, inputs, and attributes.
-            # We replace the node with the existing node.
-            modified = True
-            existing_node = existing_node_info_to_the_node[node_info]
-            _remove_node_and_replace_values(
-                graph,
-                remove_node=node,
-                remove_values=node.outputs,
-                new_values=existing_node.outputs,
+                continue
+
+            if large_tensor:
+                # If the node has a large tensor, we skip it.
+                logger.debug("Skipping large tensor in node %s", node)
+                continue
+
+            if _is_non_deterministic_op(node):
+                # If the node is a non-deterministic op, we skip it.
+                logger.debug("Skipping non-deterministic op %s", node)
+                continue
+
+            node_info = (
+                node.op_identifier(),
+                len(node.outputs),
+                tuple(id(input) for input in node.inputs),
+                tuple(sorted(attributes.items())),
             )
-            logger.debug("Reusing node %s", existing_node)
-        else:
-            # If it is not, add to the mapping.
-            existing_node_info_to_the_node[node_info] = node
-    return modified
+            # Check if the node is a common subexpression.
+            if node_info in existing_node_info_to_the_node:
+                # If it is, this node has an existing node with the same
+                # operator, number of outputs, inputs, and attributes.
+                # We replace the node with the existing node.
+                modified = True
+                existing_node = existing_node_info_to_the_node[node_info]
+                _remove_node_and_replace_values(
+                    graph,
+                    remove_node=node,
+                    remove_values=node.outputs,
+                    new_values=existing_node.outputs,
+                )
+                logger.debug("Reusing node %s", existing_node)
+            else:
+                # If it is not, add to the mapping.
+                existing_node_info_to_the_node[node_info] = node
+        return modified
 
 
 def _remove_node_and_replace_values(

onnx_ir/passes/common/initializer_deduplication.py

@@ -0,0 +1,56 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Pass for removing duplicated initializer tensors from a graph."""
+
+from __future__ import annotations
+
+__all__ = [
+    "DeduplicateInitializersPass",
+]
+
+
+import onnx_ir as ir
+
+
+class DeduplicateInitializersPass(ir.passes.InPlacePass):
+    """Remove duplicated initializer tensors from the graph.
+
+    This pass detects initializers with identical shape, dtype, and content,
+    and replaces all duplicate references with a canonical one.
+
+    To deduplicate initializers from subgraphs, use :class:`~onnx_ir.passes.common.LiftSubgraphInitializersToMainGraphPass`
+    to lift the initializers to the main graph first before running pass.
+
+    .. versionadded:: 0.1.3
+    """
+
+    def __init__(self, size_limit: int = 1024):
+        super().__init__()
+        self.size_limit = size_limit
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        graph = model.graph
+        initializers: dict[tuple[ir.DataType, tuple[int, ...], bytes], ir.Value] = {}
+        modified = False
+
+        for initializer in tuple(graph.initializers.values()):
+            # TODO(justinchuby): Handle subgraphs as well. For now users can lift initializers
+            # out from the main graph before running this pass.
+            const_val = initializer.const_value
+            if const_val is None:
+                # Skip if initializer has no constant value
+                continue
+
+            if const_val.size > self.size_limit:
+                continue
+
+            key = (const_val.dtype, tuple(const_val.shape), const_val.tobytes())
+            if key in initializers:
+                modified = True
+                ir.convenience.replace_all_uses_with(initializer, initializers[key])  # type: ignore[index]
+                assert initializer.name is not None
+                graph.initializers.pop(initializer.name)
+            else:
+                initializers[key] = initializer  # type: ignore[index]
+
+        return ir.passes.PassResult(model=model, modified=modified)

onnx_ir/serde.py

@@ -200,6 +200,9 @@ def from_onnx_text(
 
     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
@@ -237,6 +240,8 @@ def to_onnx_text(
 ) -> 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.

onnx_ir/tensor_adapters.py

@@ -29,6 +29,8 @@ Example::
 from __future__ import annotations
 
 __all__ = [
+    "from_torch_dtype",
+    "to_torch_dtype",
     "TorchTensor",
 ]
 
@@ -44,14 +46,17 @@ if TYPE_CHECKING:
     import torch
 
 
-class TorchTensor(_core.Tensor):
-    def __init__(
-        self, tensor: torch.Tensor, name: str | None = None, doc_string: str | None = None
-    ):
-        # Pass the tensor as the raw data to ir.Tensor's constructor
+_TORCH_DTYPE_TO_ONNX: dict[torch.dtype, ir.DataType] | None = None
+_ONNX_DTYPE_TO_TORCH: dict[ir.DataType, torch.dtype] | None = None
+
+
+def from_torch_dtype(dtype: torch.dtype) -> ir.DataType:
+    """Convert a PyTorch dtype to an ONNX IR DataType."""
+    global _TORCH_DTYPE_TO_ONNX
+    if _TORCH_DTYPE_TO_ONNX is None:
         import torch
 
-        _TORCH_DTYPE_TO_ONNX: dict[torch.dtype, ir.DataType] = {
+        _TORCH_DTYPE_TO_ONNX = {
             torch.bfloat16: ir.DataType.BFLOAT16,
             torch.bool: ir.DataType.BOOL,
             torch.complex128: ir.DataType.COMPLEX128,
@@ -72,8 +77,58 @@ class TorchTensor(_core.Tensor):
             torch.uint32: ir.DataType.UINT32,
             torch.uint64: ir.DataType.UINT64,
         }
+    if dtype not in _TORCH_DTYPE_TO_ONNX:
+        raise TypeError(
+            f"Unsupported PyTorch dtype '{dtype}'. "
+            "Please use a supported dtype from the list: "
+            f"{list(_TORCH_DTYPE_TO_ONNX.keys())}"
+        )
+    return _TORCH_DTYPE_TO_ONNX[dtype]
+
+
+def to_torch_dtype(dtype: ir.DataType) -> torch.dtype:
+    """Convert an ONNX IR DataType to a PyTorch dtype."""
+    global _ONNX_DTYPE_TO_TORCH
+    if _ONNX_DTYPE_TO_TORCH is None:
+        import torch
+
+        _ONNX_DTYPE_TO_TORCH = {
+            ir.DataType.BFLOAT16: torch.bfloat16,
+            ir.DataType.BOOL: torch.bool,
+            ir.DataType.COMPLEX128: torch.complex128,
+            ir.DataType.COMPLEX64: torch.complex64,
+            ir.DataType.FLOAT16: torch.float16,
+            ir.DataType.FLOAT: torch.float32,
+            ir.DataType.DOUBLE: torch.float64,
+            ir.DataType.FLOAT8E4M3FN: torch.float8_e4m3fn,
+            ir.DataType.FLOAT8E4M3FNUZ: torch.float8_e4m3fnuz,
+            ir.DataType.FLOAT8E5M2: torch.float8_e5m2,
+            ir.DataType.FLOAT8E5M2FNUZ: torch.float8_e5m2fnuz,
+            ir.DataType.INT16: torch.int16,
+            ir.DataType.INT32: torch.int32,
+            ir.DataType.INT64: torch.int64,
+            ir.DataType.INT8: torch.int8,
+            ir.DataType.UINT8: torch.uint8,
+            ir.DataType.UINT16: torch.uint16,
+            ir.DataType.UINT32: torch.uint32,
+            ir.DataType.UINT64: torch.uint64,
+        }
+    if dtype not in _ONNX_DTYPE_TO_TORCH:
+        raise TypeError(
+            f"Unsupported conversion from ONNX dtype '{dtype}' to torch. "
+            "Please use a supported dtype from the list: "
+            f"{list(_ONNX_DTYPE_TO_TORCH.keys())}"
+        )
+    return _ONNX_DTYPE_TO_TORCH[dtype]
+
+
+class TorchTensor(_core.Tensor):
+    def __init__(
+        self, tensor: torch.Tensor, name: str | None = None, doc_string: str | None = None
+    ):
+        # Pass the tensor as the raw data to ir.Tensor's constructor
         super().__init__(
-            tensor, dtype=_TORCH_DTYPE_TO_ONNX[tensor.dtype], name=name, doc_string=doc_string
+            tensor, dtype=from_torch_dtype(tensor.dtype), name=name, doc_string=doc_string
         )
 
     def numpy(self) -> npt.NDArray:

{onnx_ir-0.1.2.dist-info → onnx_ir-0.1.3.dist-info}/METADATA

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

{onnx_ir-0.1.2.dist-info → onnx_ir-0.1.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
-onnx_ir/__init__.py,sha256=aeEp01Z1OnAVSQyJ_ejLbVnvI2BJE2mTbnRgIvkTDG8,3424
-onnx_ir/_core.py,sha256=F1mQwdSSV8Y6T_yE01nQLnlBtoMs8bnchCNB3ykSaLM,137413
+onnx_ir/__init__.py,sha256=5KP1Ngl2qyWiqb5S0Ol5owYsbU0geo4LFwGwN8EXTIk,3424
+onnx_ir/_core.py,sha256=-9BpVTZHuHQ9jsms33wqu4NjMEaDF_M57sIuVxYcM1I,137964
 onnx_ir/_display.py,sha256=230bMN_hVy47Ug3HkA4o5Tf5Hr21AnBEoq5w0fxjyTs,1300
-onnx_ir/_enums.py,sha256=JX2-uUNtPQgPM6F23BslHllvR-2uZAHvKpzy2iPGg7o,8219
+onnx_ir/_enums.py,sha256=4lmm_DFKEtz6PqNw6gt6GcqrBYHisctgKMsUbQCm5N8,8252
 onnx_ir/_graph_comparison.py,sha256=8_D1gu547eCDotEUqxfIJhUGU_Ufhfji7sfsSraOj3g,727
 onnx_ir/_graph_containers.py,sha256=PRKrshRZ5rzWCgRs1TefzJq9n8wyo7OqeKy3XxMhyys,14265
 onnx_ir/_io.py,sha256=GWwA4XOZ-ZX1cgibgaYD0K0O5d9LX21ZwcBN02Wrh04,5205
@@ -15,28 +15,29 @@ onnx_ir/_type_casting.py,sha256=8iZDVrNAx_FwRVt48G4tkzIOFu3I6AsETpH3fdxcyEI,3387
 onnx_ir/_version_utils.py,sha256=bZThuE7meVHFOY1DLsmss9WshVIp9iig7udGfDbVaK4,1333
 onnx_ir/convenience.py,sha256=0B1epuXZCSmY4FbW2vaYfR-t5ubxBZ1UruiytHs-zFw,917
 onnx_ir/external_data.py,sha256=rXHtRU-9tjAt10Iervhr5lsI6Dtv-EhR7J4brxppImA,18079
-onnx_ir/serde.py,sha256=M2w-D2boYEHi96tA_4eQUGRaV4CYhxoHi-5FPmVEjRk,74968
+onnx_ir/serde.py,sha256=YkbYfQMwn0YAzTd3tVDSWJ-NBiSVsG-74T6xk3e5iTU,75073
 onnx_ir/tape.py,sha256=4FyfAHmVhQoMsfHMYnBwP2azi6UF6b6pj--ercObqZs,350
-onnx_ir/tensor_adapters.py,sha256=J2z0gxkxwZqBrob1pYT53lgz1XQ1r7kCxhoSZa5NHaQ,4469
+onnx_ir/tensor_adapters.py,sha256=dXuapwfFcpLhjKC6AOqCXbtY3WvDaEHoCNPwjnUK7_o,6565
 onnx_ir/testing.py,sha256=WTrjf2joWizDWaYMJlV1KjZMQw7YmZ8NvuBTVn1uY6s,8803
 onnx_ir/traversal.py,sha256=Z69wzYBNljn1S7PhVTYgwMftrfsdEBLoa0JYteOhLL0,2863
-onnx_ir/_convenience/__init__.py,sha256=5g5IlMfozyQcGBMsJW9HtYWzEGe5uAQVrWrDQsnMk1Q,19059
+onnx_ir/_convenience/__init__.py,sha256=DQ-Bz1wTiZJEARCFxDqZvYexWviGmwvDzE_1hR-vp0Q,19182
 onnx_ir/_convenience/_constructors.py,sha256=5GhlYy_xCE2ng7l_4cNx06WQsNDyvS-0U1HgOpPKJEk,8347
 onnx_ir/_thirdparty/asciichartpy.py,sha256=afQ0fsqko2uYRPAR4TZBrQxvCb4eN8lxZ2yDFbVQq_s,10533
 onnx_ir/passes/__init__.py,sha256=M_Tcl_-qGSNPluFIvOoeDyh0qAwNayaYyXDS5UJUJPQ,764
 onnx_ir/passes/_pass_infra.py,sha256=xIOw_zZIuOqD4Z_wZ4OvsqXfh2IZMoMlDp1xQ_MPQlc,9567
-onnx_ir/passes/common/__init__.py,sha256=aHjx2y7L7LJChixmKsSUCdiaTP1u-zSmcmEISduqeG4,1335
+onnx_ir/passes/common/__init__.py,sha256=GrrscfBekrIjxrYusgvTgP80OrgY1GMJwZMInRQmcL4,1467
 onnx_ir/passes/common/_c_api_utils.py,sha256=g6riA6xNGVWaO5YjVHZ0krrfslWHmRlryRkwB8X56cg,2907
 onnx_ir/passes/common/clear_metadata_and_docstring.py,sha256=YwouLfsNFSaTuGd7uMOGjdvVwG9yHQTkSphUgDlM0ME,2365
-onnx_ir/passes/common/common_subexpression_elimination.py,sha256=WMsTAI-12A3iVqptmWw0tiBmGwVKsls5VNxZEbjvp2A,6527
+onnx_ir/passes/common/common_subexpression_elimination.py,sha256=wZ1zEPdCshYB_ifP9fCAVfzQkesE6uhCfzCuL2qO5fA,7948
 onnx_ir/passes/common/constant_manipulation.py,sha256=_fGDwn0Axl2Q8APfc2m_mLMH28T-Mc9kIlpzBXoe3q4,8779
+onnx_ir/passes/common/initializer_deduplication.py,sha256=4CIVFYfdXUlmF2sAx560c_pTwYVXtX5hcSwWzUKm5uc,2061
 onnx_ir/passes/common/inliner.py,sha256=wBoO6yXt6F1AObQjYZHMQ0wn3YH681N4HQQVyaMAYd4,13702
 onnx_ir/passes/common/onnx_checker.py,sha256=_sPmJ2ff9pDB1g9q7082BL6fyubomRaj6svE0cCyDew,1691
 onnx_ir/passes/common/shape_inference.py,sha256=LVdvxjeKtcIEbPcb6mKisxoPJOOawzsm3tzk5j9xqeM,3992
 onnx_ir/passes/common/topological_sort.py,sha256=Vcu1YhBdfRX4LROr0NScjB1Pwz2DjBFD0Z_GxqaxPF8,999
 onnx_ir/passes/common/unused_removal.py,sha256=cBNqaqGnUVyCWxsD7hBzYk4qSglVPo3SmHAvkUo5-Oc,7613
-onnx_ir-0.1.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-onnx_ir-0.1.2.dist-info/METADATA,sha256=p5ZfMwXTfm96hlrRDgvdBGzARfeLVpAWhZ_nNSq3m78,4782
-onnx_ir-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_ir-0.1.2.dist-info/top_level.txt,sha256=W5tROO93YjO0XRxIdjMy4wocp-5st5GiI2ukvW7UhDo,8
-onnx_ir-0.1.2.dist-info/RECORD,,
+onnx_ir-0.1.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+onnx_ir-0.1.3.dist-info/METADATA,sha256=vKG8o_nAUJfjM05rahv0g-FCeHkHXIwCAcuYzSY6PH8,4782
+onnx_ir-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_ir-0.1.3.dist-info/top_level.txt,sha256=W5tROO93YjO0XRxIdjMy4wocp-5st5GiI2ukvW7UhDo,8
+onnx_ir-0.1.3.dist-info/RECORD,,