Create a identity-elimination pass (onnx#121)

This PR implements a new `IdentityEliminationPass` that removes
redundant Identity nodes from ONNX graphs according to the rules
specified in the issue.

## Implementation

The pass handles three distinct scenarios for Identity nodes of the form
`y = Identity(x)`:

1. **Case 1**: When `y` is not a graph output → Replace all uses of `y`
with `x` and remove the node
2. **Case 2**: When `y` is a graph output but `x` is not a graph input →
Eliminate the node but rename `x` to `y`
3. **Case 3**: When both `y` is a graph output and `x` is a graph input
→ Keep the node (cannot eliminate)

## Example

```python
import onnx_ir as ir
from onnx_ir.passes.common import IdentityEliminationPass

# Before: input1 -> Identity -> Add -> Identity -> output
# After:  input1 -> Add -> output (with proper renaming)

pass_instance = IdentityEliminationPass()
result = pass_instance(model)
```

## Key Features

- **Comprehensive elimination**: Handles all three scenarios correctly
- **Subgraph support**: Processes Identity nodes in functions and node
attributes
- **Chain elimination**: Can eliminate chains of Identity nodes in a
single pass
- **Safe operation**: Uses `graph.remove(node, safe=True)` to ensure
graph consistency
- **Edge case handling**: Properly handles invalid nodes, None inputs,
and empty graphs

## Testing

Added comprehensive test suite with 9 test cases covering:
- All three elimination scenarios
- Multiple Identity nodes in complex graphs
- Chain of Identity nodes
- Edge cases (invalid nodes, None inputs, empty graphs)
- Integration with PassManager

All tests pass and the implementation follows established patterns in
the codebase.

Fixes onnx#120.

<!-- START COPILOT CODING AGENT TIPS -->
---

💡 You can make Copilot smarter by setting up custom instructions,
customizing its development environment and configuring Model Context
Protocol (MCP) servers. Learn more [Copilot coding agent
tips](https://gh.io/copilot-coding-agent-tips) in the docs.

---------

Signed-off-by: Justin Chu <justinchuby@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: gramalingam <10075881+gramalingam@users.noreply.github.com>
Co-authored-by: Justin Chu <justinchuby@users.noreply.github.com>
Co-authored-by: justinchuby <11205048+justinchuby@users.noreply.github.com>
Co-authored-by: titaiwangms <18010845+titaiwangms@users.noreply.github.com>

Author: 4 people

src/onnx_ir/passes/common/__init__.py

@@ -7,6 +7,7 @@
     "ClearMetadataAndDocStringPass",
     "CommonSubexpressionEliminationPass",
     "DeduplicateInitializersPass",
+    "IdentityEliminationPass",
     "InlinePass",
     "LiftConstantsToInitializersPass",
     "LiftSubgraphInitializersToMainGraphPass",
@@ -30,6 +31,9 @@
     LiftSubgraphInitializersToMainGraphPass,
     RemoveInitializersFromInputsPass,
 )
+from onnx_ir.passes.common.identity_elimination import (
+    IdentityEliminationPass,
+)
 from onnx_ir.passes.common.initializer_deduplication import (
     DeduplicateInitializersPass,
 )

src/onnx_ir/passes/common/identity_elimination.py

@@ -0,0 +1,97 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Identity elimination pass for removing redundant Identity nodes."""
+
+from __future__ import annotations
+
+__all__ = [
+    "IdentityEliminationPass",
+]
+
+import logging
+
+import onnx_ir as ir
+
+logger = logging.getLogger(__name__)
+
+
+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,
+       we can still do the elimination, but the value `x` should be renamed to be `y`.
+    3. If `y` is a graph-output and `x` is a graph-input, we cannot eliminate
+       the node. It should be retained.
+    """
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        """Main entry point for the identity elimination pass."""
+        modified = False
+
+        # Use RecursiveGraphIterator to process all nodes in the model graph and subgraphs
+        for node in ir.traversal.RecursiveGraphIterator(model.graph):
+            if self._try_eliminate_identity_node(node):
+                modified = True
+
+        # Process nodes in functions
+        for function in model.functions.values():
+            for node in ir.traversal.RecursiveGraphIterator(function):
+                if self._try_eliminate_identity_node(node):
+                    modified = True
+
+        if modified:
+            logger.info("Identity elimination pass modified the model")
+
+        return ir.passes.PassResult(model, modified=modified)
+
+    def _try_eliminate_identity_node(self, node: ir.Node) -> bool:
+        """Try to eliminate a single identity node. Returns True if modified."""
+        if node.op_type != "Identity" or node.domain != "":
+            return False
+
+        if len(node.inputs) != 1 or len(node.outputs) != 1:
+            # Invalid Identity node, skip
+            return False
+
+        input_value = node.inputs[0]
+        output_value = node.outputs[0]
+
+        if input_value is None:
+            # Cannot eliminate if input is None
+            return False
+
+        # Get the graph that contains this node
+        graph_like = node.graph
+        assert graph_like is not None, "Node must be in a graph"
+
+        output_is_graph_output = output_value.is_graph_output()
+        input_is_graph_input = input_value.is_graph_input()
+
+        # Case 3: Both output is graph output and input is graph input - keep the node
+        if output_is_graph_output and input_is_graph_input:
+            return False
+
+        # Case 1 & 2 (merged): Eliminate the identity node
+        # Replace all uses of output with input
+        ir.convenience.replace_all_uses_with(output_value, input_value)
+
+        # If output is a graph output, we need to rename input and update graph outputs
+        if output_is_graph_output:
+            # Store the original output name
+            original_output_name = output_value.name
+
+            # Update the input value to have the output's name
+            input_value.name = original_output_name
+
+            # Update graph outputs to point to the input value
+            for idx, graph_output in enumerate(graph_like.outputs):
+                if graph_output is output_value:
+                    graph_like.outputs[idx] = input_value
+
+        # Remove the identity node
+        graph_like.remove(node, safe=True)
+        logger.debug("Eliminated identity node: %s", node)
+        return True