onnx-ir 0.1.5__tar.gz → 0.1.7__tar.gz

{onnx_ir-0.1.5/src/onnx_ir.egg-info → onnx_ir-0.1.7}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: onnx-ir
-Version: 0.1.5
+Version: 0.1.7
 Summary: Efficient in-memory representation for ONNX
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
-License: Apache License v2.0
+License-Expression: Apache-2.0
 Project-URL: Homepage, https://onnx.ai/ir-py
 Project-URL: Issues, https://github.com/onnx/ir-py/issues
 Project-URL: Repository, https://github.com/onnx/ir-py
@@ -13,7 +13,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: Apache Software License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -29,7 +28,6 @@ Dynamic: license-file
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/onnx-ir.svg)](https://pypi.org/project/onnx-ir)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![codecov](https://codecov.io/gh/onnx/ir-py/graph/badge.svg?token=SPQ3G9T78Z)](https://codecov.io/gh/onnx/ir-py)
-[![DeepWiki](https://img.shields.io/badge/DeepWiki-onnx%2Fir--py-blue.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==)](https://deepwiki.com/onnx/ir-py)
 [![PyPI Downloads](https://static.pepy.tech/badge/onnx-ir/month)](https://pepy.tech/projects/onnx-ir)
 
 An in-memory IR that supports the full ONNX spec, designed for graph construction, analysis and transformation.

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/README.md

@@ -4,7 +4,6 @@
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/onnx-ir.svg)](https://pypi.org/project/onnx-ir)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![codecov](https://codecov.io/gh/onnx/ir-py/graph/badge.svg?token=SPQ3G9T78Z)](https://codecov.io/gh/onnx/ir-py)
-[![DeepWiki](https://img.shields.io/badge/DeepWiki-onnx%2Fir--py-blue.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==)](https://deepwiki.com/onnx/ir-py)
 [![PyPI Downloads](https://static.pepy.tech/badge/onnx-ir/month)](https://pepy.tech/projects/onnx-ir)
 
 An in-memory IR that supports the full ONNX spec, designed for graph construction, analysis and transformation.

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=70"]
+requires = ["setuptools>=77"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -11,7 +11,8 @@ authors = [
 ]
 readme = "README.md"
 requires-python = ">=3.9"
-license = {text = "Apache License v2.0"}
+license = "Apache-2.0"
+license-files = ["LICEN[CS]E*"]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python :: 3.9",
@@ -19,7 +20,6 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
-  "License :: OSI Approved :: Apache Software License",
 ]
 dependencies = ["numpy", "onnx>=1.16", "typing_extensions>=4.10", "ml_dtypes"]
 

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/src/onnx_ir/__init__.py

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

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/src/onnx_ir/_convenience/__init__.py

@@ -58,44 +58,52 @@ def _infer_attribute_type(attr: SupportedAttrTypes) -> _enums.AttributeType:
         return _enums.AttributeType.STRING
     if isinstance(attr, _core.Attr):
         return attr.type
-    if isinstance(attr, Sequence) and all(isinstance(x, int) for x in attr):
-        return _enums.AttributeType.INTS
-    if isinstance(attr, Sequence) and all(isinstance(x, float) for x in attr):
-        return _enums.AttributeType.FLOATS
-    if isinstance(attr, Sequence) and all(isinstance(x, str) for x in attr):
-        return _enums.AttributeType.STRINGS
+    if isinstance(attr, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol)):
+        return _enums.AttributeType.GRAPH
     if isinstance(attr, (_core.TensorBase, onnx.TensorProto, _protocols.TensorProtocol)):
         # Be sure to check TensorProtocol last because isinstance checking on Protocols can be slower
         return _enums.AttributeType.TENSOR
-    if isinstance(attr, Sequence) and all(
-        isinstance(x, (_core.TensorBase, onnx.TensorProto, _protocols.TensorProtocol))
-        for x in attr
-    ):
-        return _enums.AttributeType.TENSORS
-    if isinstance(attr, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol)):
-        return _enums.AttributeType.GRAPH
-    if isinstance(attr, Sequence) and all(
-        isinstance(x, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol)) for x in attr
-    ):
-        return _enums.AttributeType.GRAPHS
     if isinstance(
         attr,
         (_core.TensorType, _core.SequenceType, _core.OptionalType, _protocols.TypeProtocol),
     ):
         return _enums.AttributeType.TYPE_PROTO
-    if isinstance(attr, Sequence) and all(
-        isinstance(
-            x,
-            (
-                _core.TensorType,
-                _core.SequenceType,
-                _core.OptionalType,
-                _protocols.TypeProtocol,
-            ),
-        )
-        for x in attr
-    ):
-        return _enums.AttributeType.TYPE_PROTOS
+    if isinstance(attr, Sequence):
+        if not attr:
+            logger.warning(
+                "Attribute type is ambiguous because it is an empty sequence. "
+                "Please create an Attr with an explicit type. Defaulted to INTS"
+            )
+            return _enums.AttributeType.INTS
+        if all(isinstance(x, int) for x in attr):
+            return _enums.AttributeType.INTS
+        if all(isinstance(x, float) for x in attr):
+            return _enums.AttributeType.FLOATS
+        if all(isinstance(x, str) for x in attr):
+            return _enums.AttributeType.STRINGS
+        if all(
+            isinstance(x, (_core.TensorBase, onnx.TensorProto, _protocols.TensorProtocol))
+            for x in attr
+        ):
+            return _enums.AttributeType.TENSORS
+        if all(
+            isinstance(x, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol))
+            for x in attr
+        ):
+            return _enums.AttributeType.GRAPHS
+        if all(
+            isinstance(
+                x,
+                (
+                    _core.TensorType,
+                    _core.SequenceType,
+                    _core.OptionalType,
+                    _protocols.TypeProtocol,
+                ),
+            )
+            for x in attr
+        ):
+            return _enums.AttributeType.TYPE_PROTOS
     raise TypeError(f"Unsupported attribute type: '{type(attr)}'")
 
 
@@ -218,7 +226,7 @@ def convert_attributes(
         ...     "type_protos": [ir.TensorType(ir.DataType.FLOAT), ir.TensorType(ir.DataType.FLOAT)],
         ... }
         >>> convert_attributes(attrs)
-        [Attr('int', INT, 1), Attr('float', FLOAT, 1.0), Attr('str', STRING, 'hello'), Attr('ints', INTS, [1, 2, 3]), Attr('floats', FLOATS, [1.0, 2.0, 3.0]), Attr('strings', STRINGS, ['hello', 'world']), Attr('tensor', TENSOR, Tensor<DOUBLE,[3]>(array([1., 2., 3.]), name=None)), Attr('tensor_proto', TENSOR, TensorProtoTensor<FLOAT,[3]>(array([1., 2., 3.], dtype=float32), name='proto')), Attr('graph', INTS, Graph(
+        [Attr('int', INT, 1), Attr('float', FLOAT, 1.0), Attr('str', STRING, 'hello'), Attr('ints', INTS, [1, 2, 3]), Attr('floats', FLOATS, [1.0, 2.0, 3.0]), Attr('strings', STRINGS, ['hello', 'world']), Attr('tensor', TENSOR, Tensor<DOUBLE,[3]>(array([1., 2., 3.]), name=None)), Attr('tensor_proto', TENSOR, TensorProtoTensor<FLOAT,[3]>(array([1., 2., 3.], dtype=float32), name='proto')), Attr('graph', GRAPH, Graph(
             name='graph0',
             inputs=(
         <BLANKLINE>
@@ -247,11 +255,20 @@ def convert_attributes(
             len()=0
         )]), Attr('type_proto', TYPE_PROTO, Tensor(FLOAT)), Attr('type_protos', TYPE_PROTOS, [Tensor(FLOAT), Tensor(FLOAT)])]
 
+    .. important::
+        An empty sequence should be created with an explicit type by initializing
+        an Attr object with an attribute type to avoid type ambiguity. For example::
+
+            ir.Attr("empty", [], type=ir.AttributeType.INTS)
+
     Args:
         attrs: A dictionary of {<attribute name>: <python objects>} to convert.
 
     Returns:
-        A list of _core.Attr objects.
+        A list of :class:`_core.Attr` objects.
+
+    Raises:
+        TypeError: If an attribute type is not supported.
     """
     attributes: list[_core.Attr] = []
     for name, attr in attrs.items():

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/src/onnx_ir/_core.py

@@ -2564,14 +2564,23 @@ class Graph(_protocols.GraphProtocol, Sequence[Node], _display.PrettyPrintable):
 
         .. versionadded:: 0.1.2
         """
-        seen_graphs: set[Graph] = set()
-        for node in onnx_ir.traversal.RecursiveGraphIterator(self):
-            graph = node.graph
+        # Use a dict to preserve order
+        seen_graphs: dict[Graph, None] = {}
+
+        # Need to use the enter_graph callback so that empty subgraphs are collected
+        def enter_subgraph(graph) -> None:
             if graph is self:
-                continue
-            if graph is not None and graph not in seen_graphs:
-                seen_graphs.add(graph)
-                yield graph
+                return
+            if not isinstance(graph, Graph):
+                raise TypeError(
+                    f"Expected a Graph, got {type(graph)}. The model may be invalid"
+                )
+            if graph not in seen_graphs:
+                seen_graphs[graph] = None
+
+        for _ in onnx_ir.traversal.RecursiveGraphIterator(self, enter_graph=enter_subgraph):
+            pass
+        yield from seen_graphs.keys()
 
     # Mutation methods
     def append(self, node: Node, /) -> None:
@@ -3180,6 +3189,21 @@ class Function(_protocols.FunctionProtocol, Sequence[Node], _display.PrettyPrint
     def attributes(self) -> _graph_containers.Attributes:
         return self._attributes
 
+    @property
+    def graph(self) -> Graph:
+        """The underlying Graph object that contains the nodes of this function.
+
+        Only use this graph for identity comparison::
+
+            if value.graph is function.graph:
+                # Do something with the value that belongs to this function
+
+        Otherwise use the Function object directly to access the nodes and other properties.
+
+        .. versionadded:: 0.1.7
+        """
+        return self._graph
+
     @typing.overload
     def __getitem__(self, index: int) -> Node: ...
     @typing.overload
@@ -3240,14 +3264,22 @@ class Function(_protocols.FunctionProtocol, Sequence[Node], _display.PrettyPrint
 
         .. versionadded:: 0.1.2
         """
-        seen_graphs: set[Graph] = set()
-        for node in onnx_ir.traversal.RecursiveGraphIterator(self):
-            graph = node.graph
-            if graph is self._graph:
-                continue
-            if graph is not None and graph not in seen_graphs:
-                seen_graphs.add(graph)
-                yield graph
+        seen_graphs: dict[Graph, None] = {}
+
+        # Need to use the enter_graph callback so that empty subgraphs are collected
+        def enter_subgraph(graph) -> None:
+            if graph is self:
+                return
+            if not isinstance(graph, Graph):
+                raise TypeError(
+                    f"Expected a Graph, got {type(graph)}. The model may be invalid"
+                )
+            if graph not in seen_graphs:
+                seen_graphs[graph] = None
+
+        for _ in onnx_ir.traversal.RecursiveGraphIterator(self, enter_graph=enter_subgraph):
+            pass
+        yield from seen_graphs.keys()
 
     # Mutation methods
     def append(self, node: Node, /) -> None:
@@ -3349,7 +3381,7 @@ class Attr(
 ):
     """Base class for ONNX attributes or references."""
 
-    __slots__ = ("_name", "_ref_attr_name", "_type", "_value", "doc_string")
+    __slots__ = ("_metadata", "_name", "_ref_attr_name", "_type", "_value", "doc_string")
 
     def __init__(
         self,
@@ -3365,6 +3397,7 @@ class Attr(
         self._value = value
         self._ref_attr_name = ref_attr_name
         self.doc_string = doc_string
+        self._metadata: _metadata.MetadataStore | None = None
 
     @property
     def name(self) -> str:
@@ -3386,6 +3419,17 @@ class Attr(
     def ref_attr_name(self) -> str | None:
         return self._ref_attr_name
 
+    @property
+    def meta(self) -> _metadata.MetadataStore:
+        """The metadata store for intermediate analysis.
+
+        Write to the :attr:`metadata_props` if you would like the metadata to be serialized
+        to the ONNX proto.
+        """
+        if self._metadata is None:
+            self._metadata = _metadata.MetadataStore()
+        return self._metadata
+
     def is_ref(self) -> bool:
         """Check if this attribute is a reference attribute."""
         return self.ref_attr_name is not None

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/src/onnx_ir/passes/common/__init__.py

@@ -6,11 +6,13 @@ __all__ = [
     "CheckerPass",
     "ClearMetadataAndDocStringPass",
     "CommonSubexpressionEliminationPass",
+    "DeduplicateHashedInitializersPass",
     "DeduplicateInitializersPass",
     "IdentityEliminationPass",
     "InlinePass",
     "LiftConstantsToInitializersPass",
     "LiftSubgraphInitializersToMainGraphPass",
+    "NameFixPass",
     "RemoveInitializersFromInputsPass",
     "RemoveUnusedFunctionsPass",
     "RemoveUnusedNodesPass",
@@ -35,9 +37,11 @@ from onnx_ir.passes.common.identity_elimination import (
     IdentityEliminationPass,
 )
 from onnx_ir.passes.common.initializer_deduplication import (
+    DeduplicateHashedInitializersPass,
     DeduplicateInitializersPass,
 )
 from onnx_ir.passes.common.inliner import InlinePass
+from onnx_ir.passes.common.naming import NameFixPass
 from onnx_ir.passes.common.onnx_checker import CheckerPass
 from onnx_ir.passes.common.shape_inference import ShapeInferencePass
 from onnx_ir.passes.common.topological_sort import TopologicalSortPass

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/src/onnx_ir/passes/common/constant_manipulation.py

@@ -148,6 +148,7 @@ class LiftSubgraphInitializersToMainGraphPass(ir.passes.InPlacePass):
             if graph is model.graph:
                 continue
             for name in tuple(graph.initializers):
+                assert name is not None
                 initializer = graph.initializers[name]
                 if initializer.is_graph_input():
                     # Skip the ones that are also graph inputs
@@ -156,17 +157,24 @@ class LiftSubgraphInitializersToMainGraphPass(ir.passes.InPlacePass):
                         initializer.name,
                     )
                     continue
+                if initializer.is_graph_output():
+                    logger.debug(
+                        "Initializer '%s' is used as output, so it can't be lifted",
+                        initializer.name,
+                    )
+                    continue
                 # Remove the initializer from the subgraph
                 graph.initializers.pop(name)
                 # To avoid name conflicts, we need to rename the initializer
                 # to a unique name in the main graph
-                if name in registered_initializer_names:
-                    name_count = registered_initializer_names[name]
-                    initializer.name = f"{name}_{name_count}"
-                    registered_initializer_names[name] = name_count + 1
-                else:
-                    assert initializer.name is not None
-                    registered_initializer_names[initializer.name] = 1
+                new_name = name
+                while new_name in model.graph.initializers:
+                    if name in registered_initializer_names:
+                        registered_initializer_names[name] += 1
+                    else:
+                        registered_initializer_names[name] = 1
+                    new_name = f"{name}_{registered_initializer_names[name]}"
+                initializer.name = new_name
                 model.graph.register_initializer(initializer)
                 count += 1
                 logger.debug(

{onnx_ir-0.1.5 → onnx_ir-0.1.7}/src/onnx_ir/passes/common/identity_elimination.py

@@ -19,6 +19,7 @@ class IdentityEliminationPass(ir.passes.InPlacePass):
     """Pass for eliminating redundant Identity nodes.
 
     This pass removes Identity nodes according to the following rules:
+
     1. For any node of the form `y = Identity(x)`, where `y` is not an output
        of any graph, replace all uses of `y` with a use of `x`, and remove the node.
     2. If `y` is an output of a graph, and `x` is not an input of any graph,

onnx_ir-0.1.7/src/onnx_ir/passes/common/initializer_deduplication.py

@@ -0,0 +1,167 @@
+# 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", "DeduplicateHashedInitializersPass"]
+
+
+import hashlib
+import logging
+
+import onnx_ir as ir
+
+logger = logging.getLogger(__name__)
+
+
+def _should_skip_initializer(initializer: ir.Value, size_limit: int) -> bool:
+    """Check if the initializer should be skipped for deduplication."""
+    if initializer.is_graph_input() or initializer.is_graph_output():
+        # Skip graph inputs and outputs
+        logger.warning(
+            "Skipped deduplication of initializer '%s' as it is a graph input or output",
+            initializer.name,
+        )
+        return True
+
+    const_val = initializer.const_value
+    if const_val is None:
+        # Skip if initializer has no constant value
+        logger.warning(
+            "Skipped deduplication of initializer '%s' as it has no constant value. The model may contain invalid initializers",
+            initializer.name,
+        )
+        return True
+
+    if const_val.size > size_limit:
+        # Skip if the initializer is larger than the size limit
+        logger.debug(
+            "Skipped initializer '%s' as it exceeds the size limit of %d elements",
+            initializer.name,
+            size_limit,
+        )
+        return True
+
+    if const_val.dtype == ir.DataType.STRING:
+        # Skip string initializers as they don't have a bytes representation
+        logger.warning(
+            "Skipped deduplication of string initializer '%s' (unsupported yet)",
+            initializer.name,
+        )
+        return True
+    return False
+
+
+class DeduplicateInitializersPass(ir.passes.InPlacePass):
+    """Remove duplicated initializer tensors from the main graph and all subgraphs.
+
+    This pass detects initializers with identical shape, dtype, and content,
+    and replaces all duplicate references with a canonical one.
+
+    Initializers are deduplicated within each graph. To deduplicate initializers
+    in the model globally (across graphs), use :class:`~onnx_ir.passes.common.LiftSubgraphInitializersToMainGraphPass`
+    to lift the initializers to the main graph first before running pass.
+
+    .. versionadded:: 0.1.3
+    .. versionchanged:: 0.1.7
+        This pass now deduplicates initializers in subgraphs as well.
+    """
+
+    def __init__(self, size_limit: int = 1024):
+        super().__init__()
+        self.size_limit = size_limit
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        modified = False
+
+        for graph in model.graphs():
+            initializers: dict[tuple[ir.DataType, tuple[int, ...], bytes], ir.Value] = {}
+            for initializer in tuple(graph.initializers.values()):
+                if _should_skip_initializer(initializer, self.size_limit):
+                    continue
+
+                const_val = initializer.const_value
+                assert const_val is not None
+
+                key = (const_val.dtype, tuple(const_val.shape), const_val.tobytes())
+                if key in initializers:
+                    modified = True
+                    initializer_to_keep = initializers[key]  # type: ignore[index]
+                    ir.convenience.replace_all_uses_with(initializer, initializer_to_keep)
+                    assert initializer.name is not None
+                    graph.initializers.pop(initializer.name)
+                    logger.info(
+                        "Replaced initializer '%s' with existing initializer '%s'",
+                        initializer.name,
+                        initializer_to_keep.name,
+                    )
+                else:
+                    initializers[key] = initializer  # type: ignore[index]
+
+        return ir.passes.PassResult(model=model, modified=modified)
+
+
+class DeduplicateHashedInitializersPass(ir.passes.InPlacePass):
+    """Remove duplicated initializer tensors (using a hashed method) from the graph.
+
+    This pass detects initializers with identical shape, dtype, and hashed content,
+    and replaces all duplicate references with a canonical one.
+
+    This pass should have a lower peak memory usage than :class:`DeduplicateInitializersPass`
+    as it does not store the full tensor data in memory, but instead uses a hash of the tensor data.
+
+    .. versionadded:: 0.1.7
+    """
+
+    def __init__(self, size_limit: int = 4 * 1024 * 1024 * 1024):
+        super().__init__()
+        # 4 GB default size limit for deduplication
+        self.size_limit = size_limit
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        modified = False
+
+        for graph in model.graphs():
+            initializers: dict[tuple[ir.DataType, tuple[int, ...], str], ir.Value] = {}
+
+            for initializer in tuple(graph.initializers.values()):
+                if _should_skip_initializer(initializer, self.size_limit):
+                    continue
+
+                const_val = initializer.const_value
+                assert const_val is not None
+
+                # Hash tensor data to avoid storing large amounts of data in memory
+                hashed = hashlib.sha512()
+                tensor_data = const_val.numpy()
+                hashed.update(tensor_data)
+                tensor_digest = hashed.hexdigest()
+
+                tensor_dims = tuple(const_val.shape.numpy())
+
+                key = (const_val.dtype, tensor_dims, tensor_digest)
+
+                if key in initializers:
+                    if initializers[key].const_value.tobytes() != const_val.tobytes():
+                        logger.warning(
+                            "Initializer deduplication failed: "
+                            "hashes match but values differ with values %s and %s",
+                            initializers[key],
+                            initializer,
+                        )
+                        continue
+                    modified = True
+                    initializer_to_keep = initializers[key]  # type: ignore[index]
+                    ir.convenience.replace_all_uses_with(initializer, initializer_to_keep)
+                    assert initializer.name is not None
+                    graph.initializers.pop(initializer.name)
+                    logger.info(
+                        "Replaced initializer '%s' with existing initializer '%s'",
+                        initializer.name,
+                        initializer_to_keep.name,
+                    )
+                else:
+                    initializers[key] = initializer  # type: ignore[index]
+
+        return ir.passes.PassResult(model=model, modified=modified)