onnxslim 0.1.82__py3-none-any.whl → 0.1.84__py3-none-any.whl

onnxslim/core/optimization/dead_node_elimination.py

@@ -53,10 +53,17 @@ def dead_node_elimination(graph, is_subgraph=False):
                     node.inputs.pop(1)
                     node.inputs.insert(1, reshape_const)
                     logger.debug(f"replacing {node.op} op: {node.name}")
-        # elif node.op == "Slice":
-        #     if node.inputs[0].shape and node.outputs[0].shape and node.inputs[0].shape == node.outputs[0].shape and all(isinstance(item, int) for item in node.inputs[0].shape):
-        #         node.erase()
-        #         logger.debug(f"removing {node.op} op: {node.name}")
+        elif node.op == "Slice":
+            if (node.inputs[0].shape and node.outputs[0].shape
+                and node.inputs[0].shape == node.outputs[0].shape
+                and all(isinstance(item, int) for item in node.inputs[0].shape)):
+
+                # Check if slice is a no-op by analyzing parameters directly
+                # Slice inputs: data, starts, ends, [axes], [steps]
+                if is_noop_slice(node):
+                    node.erase()
+                    logger.debug(f"removing {node.op} op: {node.name}")
+
         elif node.op == "Mul":
             if (isinstance(node.inputs[1], Constant) and isinstance(node.inputs[0], Variable)) or (
                 isinstance(node.inputs[0], Constant) and isinstance(node.inputs[1], Variable)
@@ -153,3 +160,77 @@ def get_constant_variable(node, return_idx=False):
     for idx, input in enumerate(list(node.inputs)):
         if isinstance(input, Constant):
             return (idx, input) if return_idx else input
+
+
+def is_noop_slice(node):
+    """Check if a Slice node is a no-op by analyzing its parameters directly.
+
+    A Slice is a no-op when it extracts the entire tensor, i.e., for each sliced axis:
+    - start == 0 (or equivalent negative index)
+    - end >= dim_size (or is INT_MAX-like value)
+    - step == 1
+    """
+    # Slice inputs: data, starts, ends, [axes], [steps]
+    if len(node.inputs) < 3:
+        return False
+
+    data_shape = node.inputs[0].shape
+    if not data_shape or not all(isinstance(d, int) for d in data_shape):
+        return False
+
+    # Get starts and ends (required)
+    starts_input = node.inputs[1]
+    ends_input = node.inputs[2]
+
+    if not isinstance(starts_input, Constant) or not isinstance(ends_input, Constant):
+        return False
+
+    starts = starts_input.values.flatten().tolist()
+    ends = ends_input.values.flatten().tolist()
+
+    # Get axes (optional, defaults to [0, 1, 2, ...])
+    if len(node.inputs) > 3 and isinstance(node.inputs[3], Constant):
+        axes = node.inputs[3].values.flatten().tolist()
+    else:
+        axes = list(range(len(starts)))
+
+    # Get steps (optional, defaults to [1, 1, 1, ...])
+    if len(node.inputs) > 4 and isinstance(node.inputs[4], Constant):
+        steps = node.inputs[4].values.flatten().tolist()
+    else:
+        steps = [1] * len(starts)
+
+    # Check each axis
+    ndim = len(data_shape)
+    for start, end, axis, step in zip(starts, ends, axes, steps):
+        # Normalize negative axis
+        if axis < 0:
+            axis = ndim + axis
+
+        if axis < 0 or axis >= ndim:
+            return False
+
+        dim_size = data_shape[axis]
+
+        # Step must be 1 for no-op
+        if step != 1:
+            return False
+
+        # Normalize negative start index
+        if start < 0:
+            start = max(0, dim_size + start)
+
+        # Start must be 0
+        if start != 0:
+            return False
+
+        # Normalize negative end index
+        if end < 0:
+            end = dim_size + end
+
+        # End must cover the entire dimension
+        # Common patterns: end == dim_size, or end is a large value like INT_MAX
+        if end < dim_size:
+            return False
+
+    return True

onnxslim/core/pattern/elimination/slice.py

@@ -39,6 +39,16 @@ class SlicePatternMatcher(PatternMatcher):
                 first_slice_node_axes = first_slice_node_inputs[3].values.tolist()
                 first_slice_node_steps = first_slice_node_inputs[4].values.tolist()
 
+                # Check all users upfront before modifying the graph.
+                # If any user has overlapping axes, skip the optimization entirely
+                # to avoid corrupting the graph (fixes GitHub issue #277).
+                for user_node in first_slice_node_users:
+                    second_slice_node_inputs = list(user_node.inputs)
+                    second_slice_node_axes = second_slice_node_inputs[3].values.tolist()
+                    new_axes = first_slice_node_axes + second_slice_node_axes
+                    if len(new_axes) != len(set(new_axes)):
+                        return match_case
+
                 for user_node in first_slice_node_users:
                     second_slice_node = user_node
                     second_slice_node_inputs = list(second_slice_node.inputs)
@@ -52,33 +62,30 @@ class SlicePatternMatcher(PatternMatcher):
                     new_axes = first_slice_node_axes + second_slice_node_axes
                     new_steps = first_slice_node_steps + second_slice_node_steps
 
-                    if len(new_axes) != len(set(new_axes)):
-                        continue
-
                     inputs = []
+                    output_name = second_slice_node.outputs[0].name
                     inputs.extend(
                         (
                             next(iter(first_slice_node.inputs)),
                             gs.Constant(
-                                second_slice_node_inputs[1].name + "_starts",
+                                output_name + "_starts",
                                 values=np.array(new_starts, dtype=np.int64),
                             ),
                             gs.Constant(
-                                second_slice_node_inputs[2].name + "_ends",
+                                output_name + "_ends",
                                 values=np.array(new_ends, dtype=np.int64),
                             ),
                             gs.Constant(
-                                second_slice_node_inputs[3].name + "_axes",
+                                output_name + "_axes",
                                 values=np.array(new_axes, dtype=np.int64),
                             ),
                             gs.Constant(
-                                second_slice_node_inputs[4].name + "_steps",
+                                output_name + "_steps",
                                 values=np.array(new_steps, dtype=np.int64),
                             ),
                         )
                     )
                     outputs = list(second_slice_node.outputs)
-
                     first_slice_node.outputs.clear()
                     second_slice_node.inputs.clear()
                     second_slice_node.outputs.clear()

onnxslim/core/pattern/fusion/concat_reshape.py

@@ -36,9 +36,11 @@ class ConcatReshapeMatcher(PatternMatcher):
     def rewrite(self, opset=11):
         match_case = {}
         concat_node = self.concat_0
+        reshape_node = self.reshape_0
         index = next(idx for idx, i in enumerate(concat_node.inputs) if isinstance(i, gs.Variable))
+        output_name = reshape_node.outputs[0].name
         constant = gs.Constant(
-            concat_node.inputs[index].name + "_fixed",
+            output_name + "_fixed",
             values=np.array([-1], dtype=np.int64),
         )
         concat_node.inputs.pop(index)

onnxslim/core/pattern/fusion/convadd.py

@@ -27,12 +27,13 @@ class ConvAddMatcher(PatternMatcher):
         conv_weight = list(conv_node.inputs)[1]
         conv_node_users = conv_node.users
         node = self.add_0
+        oc_axis = 0 if conv_node.op == "Conv" else 1 # output_channel_axis
         if (
             len(conv_node_users) == 1
             and isinstance(node.inputs[1], gs.Constant)
             and isinstance(conv_weight, gs.Constant)
             and node.inputs[1].values.squeeze().ndim == 1
-            and node.inputs[1].values.squeeze().shape[0] == conv_weight.shape[0]
+            and node.inputs[1].values.squeeze().shape[0] == conv_weight.shape[oc_axis]
         ):
             add_node = node
             if len(conv_node.inputs) == 2:
@@ -43,12 +44,8 @@ class ConvAddMatcher(PatternMatcher):
             inputs = []
             inputs.append(next(iter(conv_node.inputs)))
             inputs.append(conv_weight)
-            weight_name = list(conv_node.inputs)[1].name
-            if weight_name.endswith("weight"):
-                bias_name = f"{weight_name[:-6]}bias"
-            else:
-                bias_name = f"{weight_name}_bias"
-            inputs.append(gs.Constant(bias_name, values=conv_bias))
+            output_name = add_node.outputs[0].name
+            inputs.append(gs.Constant(output_name + "_bias", values=conv_bias))
             outputs = list(add_node.outputs)
 
             conv_node.outputs.clear()
@@ -66,5 +63,24 @@ class ConvAddMatcher(PatternMatcher):
 
         return match_case
 
+class ConvTransposeAddMatcher(ConvAddMatcher):
+    def __init__(self, priority):
+        """Initializes the ConvTransposeAddMatcher for fusing ConvTranspose and Add layers in an ONNX graph."""
+        pattern = Pattern(
+            """
+            input             input  0  1 conv_0
+            ConvTranspose     conv_0 1+ 1 input bn_0
+            Add               add_0  2  1 conv_0 ? output
+            output            output 1  0 add_0
+            """
+        )
+        super(ConvAddMatcher, self).__init__(pattern, priority)
+
+    @property
+    def name(self):
+        """Returns the name of the FusionConvTransposeAdd pattern."""
+        return "FusionConvTransposeAdd"
+
 
 register_fusion_pattern(ConvAddMatcher(1))
+register_fusion_pattern(ConvTransposeAddMatcher(1))

onnxslim/core/pattern/fusion/convbn.py

@@ -44,25 +44,19 @@ class ConvBatchNormMatcher(PatternMatcher):
                 conv_transpose_bias = conv_transpose_node.inputs[2].values
 
             bn_var_rsqrt = bn_scale / np.sqrt(bn_running_var + bn_eps)
+            oc_axis = 0 if conv_transpose_node.op == "Conv" else 1 # output_channel_axis
             shape = [1] * len(conv_transpose_weight.shape)
-            if bn_node.i(0).op == "Conv":
-                shape[0] = -1
-            else:
-                shape[1] = -1
+            shape[oc_axis] = -1
             conv_w = conv_transpose_weight * bn_var_rsqrt.reshape(shape)
             conv_b = (conv_transpose_bias - bn_running_mean) * bn_var_rsqrt + bn_bias
 
             inputs = []
             inputs.append(next(iter(conv_transpose_node.inputs)))
-            weight_name = list(conv_transpose_node.inputs)[1].name
-            if weight_name.endswith("weight"):
-                bias_name = f"{weight_name[:-6]}bias"
-            else:
-                bias_name = f"{weight_name}_bias"
+            output_name = bn_node.outputs[0].name
             inputs.extend(
                 (
-                    gs.Constant(weight_name + "_weight", values=conv_w),
-                    gs.Constant(bias_name, values=conv_b),
+                    gs.Constant(output_name + "_weight", values=conv_w),
+                    gs.Constant(output_name + "_bias", values=conv_b),
                 )
             )
             outputs = list(bn_node.outputs)
@@ -82,5 +76,24 @@ class ConvBatchNormMatcher(PatternMatcher):
 
         return match_case
 
+class ConvTransposeBatchNormMatcher(ConvBatchNormMatcher):
+    def __init__(self, priority):
+        """Initializes the ConvTransposeBatchNormMatcher for fusing ConvTranspose and BatchNormalization layers in an ONNX graph."""
+        pattern = Pattern(
+            """
+            input              input  0  1 conv_0
+            ConvTranspose      conv_0 1+ 1 input bn_0
+            BatchNormalization bn_0   5  1 conv_0 ? ? ? ? output
+            output             output 1  0 bn_0
+            """
+        )
+        super(ConvBatchNormMatcher, self).__init__(pattern, priority)
+
+    @property
+    def name(self):
+        """Returns the name of the FusionConvTransposeBN pattern."""
+        return "FusionConvTransposeBN"
+
 
 register_fusion_pattern(ConvBatchNormMatcher(1))
+register_fusion_pattern(ConvTransposeBatchNormMatcher(1))

onnxslim/core/pattern/fusion/convmul.py

@@ -28,25 +28,23 @@ class ConvMulMatcher(PatternMatcher):
         conv_weight = list(conv_node.inputs)[1]
         if len(conv_node.users) == 1 and conv_node.users[0] == mul_node and isinstance(mul_node.inputs[1], gs.Constant):
             mul_constant = mul_node.inputs[1].values
-
-            if mul_constant.squeeze().ndim == 1 and mul_constant.squeeze().shape[0] == conv_weight.shape[0]:
-                weight_shape = conv_weight.values.shape
-                reshape_shape = [-1] + [1] * (len(weight_shape) - 1)
-
+            oc_axis = 0 if conv_node.op == "Conv" else 1 # output_channel_axis
+            if mul_constant.squeeze().ndim == 1 and mul_constant.squeeze().shape[0] == conv_weight.shape[oc_axis]:
+                reshape_shape = [1] * len(conv_weight.values.shape)
+                reshape_shape[oc_axis] = -1
                 mul_scale_reshaped = mul_constant.squeeze().reshape(reshape_shape)
                 new_weight = conv_weight.values * mul_scale_reshaped
 
                 inputs = []
                 inputs.append(next(iter(conv_node.inputs)))
 
-                weight_name = list(conv_node.inputs)[1].name
-                inputs.append(gs.Constant(weight_name, values=new_weight))
+                output_name = mul_node.outputs[0].name
+                inputs.append(gs.Constant(output_name + "_weight", values=new_weight))
 
                 if len(conv_node.inputs) == 3:
                     conv_bias = conv_node.inputs[2].values
                     new_bias = conv_bias * mul_constant.squeeze()
-                    bias_name = list(conv_node.inputs)[2].name
-                    inputs.append(gs.Constant(bias_name, values=new_bias))
+                    inputs.append(gs.Constant(output_name + "_bias", values=new_bias))
 
                 outputs = list(mul_node.outputs)
 
@@ -65,5 +63,24 @@ class ConvMulMatcher(PatternMatcher):
 
         return match_case
 
+class ConvTransposeMulMatcher(ConvMulMatcher):
+    def __init__(self, priority):
+        """Initializes the ConvTransposeMulMatcher for fusing ConvTranspose and Mul layers in an ONNX graph."""
+        pattern = Pattern(
+            """
+            input            input  0  1 conv_0
+            ConvTranspose    conv_0 1+ 1 input mul_0
+            Mul              mul_0  2  1 conv_0 ? output
+            output           output 1  0 mul_0
+            """
+        )
+        super(ConvMulMatcher, self).__init__(pattern, priority)
+
+    @property
+    def name(self):
+        """Returns the name of the FusionConvTransposeMul pattern."""
+        return "FusionConvTransposeMul"
+
 
 register_fusion_pattern(ConvMulMatcher(1))
+register_fusion_pattern(ConvTransposeMulMatcher(1))

onnxslim/core/pattern/fusion/gemm.py

@@ -76,7 +76,7 @@ class MatMulAddPatternMatcher(PatternMatcher):
                 output_variable.outputs.remove(add_node)
 
                 matmul_bias_transpose_constant = gs.Constant(
-                    matmul_bias_variable.name, values=matmul_bias_variable.values.T
+                    f"{matmul_node.name}_weight", values=matmul_bias_variable.values.T
                 )
 
                 inputs = []
@@ -143,7 +143,7 @@ class MatMulAddPatternMatcher(PatternMatcher):
                 output_variable.outputs.remove(add_node)
 
                 matmul_bias_transpose_constant = gs.Constant(
-                    matmul_bias_variable.name, values=matmul_bias_variable.values.T
+                    f"{matmul_node.name}_weight", values=matmul_bias_variable.values.T
                 )
 
                 inputs = []
@@ -235,14 +235,15 @@ class GemmMulPatternMatcher(PatternMatcher):
                     gemm_weight_fused = gemm_weight * mul_weight[:, None]
                 else:
                     gemm_weight_fused = gemm_weight * mul_weight
-                gemm_weight_fused_constant = gs.Constant(gemm_weight_constant.name + "_fused", values=gemm_weight_fused)
+                output_name = reshape_node.outputs[0].name
+                gemm_weight_fused_constant = gs.Constant(output_name + "_weight_fused", values=gemm_weight_fused)
                 gemm_node.inputs[1] = gemm_weight_fused_constant
 
                 if gemm_bias_constant:
                     gemm_bias = gemm_bias_constant.values
                     mul_bias = mul_bias_variable.values
                     gemm_bias_fused = gemm_bias * mul_bias
-                    gemm_bias_fused_constant = gs.Constant(gemm_bias_constant.name + "_fused", values=gemm_bias_fused)
+                    gemm_bias_fused_constant = gs.Constant(output_name + "_bias_fused", values=gemm_bias_fused)
                     gemm_node.inputs[2] = gemm_bias_fused_constant
 
                 mul_node.replace_all_uses_with(reshape_node)
@@ -312,7 +313,8 @@ class GemmAddPatternMatcher(PatternMatcher):
                     and add_bias.ndim <= 2
                 ):
                     gemm_bias_fused = gemm_bias + add_bias
-                    gemm_bias_fused_constant = gs.Constant(gemm_bias_constant.name + "_fused", values=gemm_bias_fused)
+                    output_name = reshape_node.outputs[0].name
+                    gemm_bias_fused_constant = gs.Constant(output_name + "_bias_fused", values=gemm_bias_fused)
                     gemm_node.inputs[2] = gemm_bias_fused_constant
                 else:
                     return match_case

onnxslim/core/pattern/fusion/padconv.py

@@ -37,6 +37,8 @@ class PadConvMatcher(PatternMatcher):
         pad_node_users = pad_node.users
 
         pad_inputs = len(pad_node.inputs)
+        auto_pad = pad_node.attrs.get("auto_pad", "NOTSET")
+
         if pad_inputs < 3 or (
             (pad_inputs >= 3 and (isinstance(pad_node.inputs[2], gs.Constant) and pad_node.inputs[2].values == 0))
             or (pad_inputs >= 3 and (isinstance(pad_node.inputs[2], gs.Variable) and pad_node.inputs[2].name == ""))
@@ -45,6 +47,7 @@ class PadConvMatcher(PatternMatcher):
                 isinstance(pad_node.inputs[1], gs.Constant)
                 and pad_node.attrs.get("mode", "constant") == "constant"
                 and conv_node.inputs[1].shape
+                and (auto_pad == "NOTSET" or auto_pad == "VALID")
             ):
                 conv_weight_dim = len(conv_node.inputs[1].shape)
                 pad_value = pad_node.inputs[1].values.tolist()
@@ -74,6 +77,8 @@ class PadConvMatcher(PatternMatcher):
                         pads = [pad + conv_pad for pad, conv_pad in zip(pads, conv_pads)]
 
                     attrs["pads"] = pads
+                    conv_node.attrs.pop("auto_pad", None)
+
                     match_case[conv_node.name] = {
                         "op": "Conv",
                         "inputs": inputs,