Merge branch 'main' into gh/trivedivivek/111/orig

Author: trivedivivek

.github/workflows/trunk.yml

@@ -262,7 +262,7 @@ jobs:
         output=$(ls -la ${elf})
         arr=($output)
         size=${arr[4]}
-        threshold="102400" # 100KiB
+        threshold="103068" # ~100KiB
         echo "size: $size, threshold: $threshold"
         if [[ "$size" -le "$threshold" ]]; then
           echo "Success $size <= $threshold"

backends/arm/_passes/annotate_channels_last_dim_order_pass.py

@@ -35,7 +35,10 @@
 def _transpose_impl(*args, **kwargs):
     # Validate length of dim_order array
     dim = args[1]
-    assert len(dim) in (4, 5)
+    if len(dim) != 4 and len(dim) != 5:
+        raise ValueError(
+            f"Dim order length must be either 4 or 5, got {len(dim)}: {dim}"
+        )
     # Pass-through in edge-IR
     return args[0]
 

backends/arm/_passes/convert_split_to_slice.py

@@ -41,9 +41,14 @@ def call(self, graph_module: torch.fx.GraphModule):
             dim = split_node.args[2] if len(split_node.args) > 2 else 0
             dim = (dim + rank) % rank
 
-            assert (
-                sum(split_lengths) == shape[dim]
-            ), "Given split lengths don't sum up to the size of the dimension."
+            # Validate that split lengths cover the entire dimension
+            length_sum = sum(split_lengths)
+            dim_size = shape[dim]
+            if length_sum != dim_size:
+                raise ValueError(
+                    f"Split sizes {split_lengths} sum to {length_sum}, "
+                    f"but dimension {dim} has size {dim_size}"
+                )
 
             # Convert split argument 'split_lengths' to slice arguments start and end.
             starts = [0] * len(split_lengths)

backends/arm/_passes/fold_qdq_with_annotated_qparams_pass.py

@@ -120,7 +120,9 @@ def fold_and_annotate_arg(
         if input_qparams is not None:
             node.meta["input_qparams"][i] = input_qparams
             for n in nodes_to_remove:
-                assert n.target == dq_op
+                if n.target != dq_op:
+                    raise RuntimeError(f"Expected {dq_op} dq_op, got {n.target}")
+
                 n.replace_all_uses_with(n.args[0])  # type: ignore[arg-type]
                 graph_module.graph.erase_node(n)
 
@@ -136,14 +138,16 @@ def call(self, graph_module: GraphModule) -> PassResult:
                 continue
 
             # Make sure we haven't already set qparams meta information on the node
-            assert "input_qparams" not in n.meta, (
-                f'Unexpected key "input_qparams" found in meta for node {n}. '
-                "input_qparams should not have been set at this point"
-            )
-            assert "output_qparams" not in n.meta, (
-                f'Unexpected key "output_qparams" found in meta for node {n}. '
-                "output_qparams should not have been set at this point"
-            )
+            if "input_qparams" in n.meta:
+                raise RuntimeError(
+                    f'Unexpected key "input_qparams" found in meta for node {n}. '
+                    "input_qparams should not have been set at this point"
+                )
+            if "output_qparams" in n.meta:
+                raise RuntimeError(
+                    f'Unexpected key "output_qparams" found in meta for node {n}. '
+                    "output_qparams should not have been set at this point"
+                )
 
             # for the inputs and outputs search the graph for quantization info and
             # store the information in a dict with order of the _tensor_ inputs as key,

backends/arm/_passes/insert_table_ops.py

@@ -240,8 +240,17 @@ def call(self, graph_module: GraphModule) -> PassResult:
                     args=(node.args[0],),
                 )
                 output_node = table_node
-                assert len(input_qparams) == 1
-                assert len(output_qparams) == 1
+                # Expect exactly one quantization parameter for input and output
+                if len(input_qparams) != 1:
+                    raise ValueError(
+                        f"InsertTableOpsPass expected exactly one input quantization parameter, "
+                        f"got {len(input_qparams)} for node {node.name}"
+                    )
+                if len(output_qparams) != 1:
+                    raise ValueError(
+                        f"InsertTableOpsPass expected exactly one output quantization parameter, "
+                        f"got {len(output_qparams)} for node {node.name}"
+                    )
 
                 # Generate table buffer and how much to lshift the table output.
                 buffer, lshift = self.generate_table_values(

backends/arm/_passes/remove_clone_pass.py

@@ -17,5 +17,8 @@ def call_operator(self, op, args, kwargs, meta):
         if op != exir_ops.edge.aten.clone.default:
             return super().call_operator(op, args, kwargs, meta)
 
-        assert len(args) == 1
+        if len(args) != 1:
+            raise ValueError(
+                f"clone operator expects exactly one argument, got {len(args)}"
+            )
         return args[0]

backends/arm/operators/op_upsample_bilinear2d.py

@@ -49,15 +49,18 @@ def define_node(
         input_dtype = inputs[0].dtype
 
         # tosa_shape output is NHWC, take HW
-        input_size_yx = torch.tensor(
-            tosa_shape(inputs[0].shape, inputs[0].dim_order)[1:3]
-        )
-        # Ignore scale and size parameters, directly use the output size as
-        # we only support static shapes currently
-        output_size_yx = torch.tensor(tosa_shape(output.shape, output.dim_order)[1:3])
+        input_size_yx = tuple([inputs[0].shape[dim] for dim in inputs[0].dim_order])[
+            1:3
+        ]
+        output_size_yx = tuple([output.shape[dim] for dim in output.dim_order])[1:3]
 
+        # Get align_corners value from the node arguments.
+        align_corners = bool(node.args[2])
         scale_n_yx, scale_d_yx, offset_yx, border_yx = get_resize_parameters(
-            input_size_yx, output_size_yx, ResizeMode.NEAREST, align_corners=True
+            input_size_yx,
+            output_size_yx,
+            ResizeMode.NEAREST,
+            align_corners=align_corners,
         )
 
         def in_int16_range(x):
@@ -139,15 +142,18 @@ def define_node(
         input_dtype = inputs[0].dtype
 
         # tosa_shape output is NHWC, take HW
-        input_size_yx = torch.tensor(
-            tosa_shape(inputs[0].shape, inputs[0].dim_order)[1:3]
-        )
-        # Ignore scale and size parameters, directly use the output size as
-        # we only support static shapes currently
-        output_size_yx = torch.tensor(tosa_shape(output.shape, output.dim_order)[1:3])
+        input_size_yx = tuple([inputs[0].shape[dim] for dim in inputs[0].dim_order])[
+            1:3
+        ]
+        output_size_yx = tuple([output.shape[dim] for dim in output.dim_order])[1:3]
 
+        # Get align_corners value from the node arguments.
+        align_corners = bool(node.args[2])
         scale_n_yx, scale_d_yx, offset_yx, border_yx = get_resize_parameters(
-            input_size_yx, output_size_yx, ResizeMode.NEAREST, align_corners=True
+            input_size_yx,
+            output_size_yx,
+            ResizeMode.NEAREST,
+            align_corners=align_corners,
         )
 
         def in_int16_range(x):

backends/arm/operators/op_upsample_nearest2d.py

@@ -17,7 +17,7 @@
     validate_same_dtype,
 )
 from executorch.backends.arm.tosa_mapping import TosaArg
-from executorch.backends.arm.tosa_utils import get_resize_parameters, tosa_shape
+from executorch.backends.arm.tosa_utils import get_resize_parameters
 
 from tosa_tools.v0_80.tosa.ResizeMode import ResizeMode  # type: ignore
 
@@ -43,19 +43,16 @@ def define_node(
         validate_num_inputs(self.target, inputs, 3)
         validate_same_dtype(self.target, [inputs[0], output])
 
-        if inputs[0].shape is None or output.shape is None:
-            raise ValueError("Only static shapes are supported")
-
         # tosa_shape output is NHWC, take HW
-        input_size_yx = torch.tensor(
-            tosa_shape(inputs[0].shape, inputs[0].dim_order)[1:3]
-        )
-        # Ignore scale and size parameters, directly use the output size as
-        # we only support static shapes currently
-        output_size_yx = torch.tensor(tosa_shape(output.shape, output.dim_order)[1:3])
+        input_size_yx = tuple([inputs[0].shape[dim] for dim in inputs[0].dim_order])[
+            1:3
+        ]
+        output_size_yx = tuple([output.shape[dim] for dim in output.dim_order])[1:3]
 
+        # Align corners shouldn't make a difference for nearest upsampling. We set to False so
+        # half pixel centers are used for resize parameter logic.
         scale_n_yx, scale_d_yx, offset_yx, border_yx = get_resize_parameters(
-            input_size_yx, output_size_yx, ResizeMode.NEAREST, align_corners=True
+            input_size_yx, output_size_yx, ResizeMode.NEAREST, align_corners=False
         )
 
         def in_int16_range(x):
@@ -102,19 +99,16 @@ def define_node(
         validate_num_inputs(self.target, inputs, 3)
         validate_same_dtype(self.target, [inputs[0], output])
 
-        if inputs[0].shape is None or output.shape is None:
-            raise ValueError("Only static shapes are supported")
-
         # tosa_shape output is NHWC, take HW
-        input_size_yx = torch.tensor(
-            tosa_shape(inputs[0].shape, inputs[0].dim_order)[1:3]
-        )
-        # Ignore scale and size parameters, directly use the output size as
-        # we only support static shapes currently
-        output_size_yx = torch.tensor(tosa_shape(output.shape, output.dim_order)[1:3])
+        input_size_yx = tuple([inputs[0].shape[dim] for dim in inputs[0].dim_order])[
+            1:3
+        ]
+        output_size_yx = tuple([output.shape[dim] for dim in output.dim_order])[1:3]
 
+        # Align corners shouldn't make a difference for nearest upsampling. We set to False so
+        # half pixel centers are used for resize parameter logic.
         scale_n_yx, scale_d_yx, offset_yx, border_yx = get_resize_parameters(
-            input_size_yx, output_size_yx, ResizeMode.NEAREST, align_corners=True
+            input_size_yx, output_size_yx, ResizeMode.NEAREST, align_corners=False
         )
 
         def in_int16_range(x):

backends/arm/test/ops/test_upsample_nearest2d.py

@@ -40,6 +40,17 @@
     "rand_one_and_half_size": lambda: (torch.rand(2, 4, 8, 3), (12, 4), None, False),
 }
 
+test_data_suite_dynamic = {
+    # (test_name, test_data, size, scale_factor, compare_outputs)
+    "rand_double_scale": lambda: (torch.rand(2, 4, 8, 3), None, 2.0, False),
+    "rand_double_scale_one_dim": lambda: (
+        torch.rand(2, 4, 8, 3),
+        None,
+        (1.0, 2.0),
+        False,
+    ),
+}
+
 
 class UpsamplingNearest2d(torch.nn.Module):
     def __init__(
@@ -161,3 +172,159 @@ def test_upsample_nearest2d_vec_tosa_BI_nearest(test_data: torch.Tensor):
         pipeline.pop_stage(-1)
 
     pipeline.run()
+
+
+@common.parametrize("test_data", test_data_suite_dynamic)
+def test_upsample_nearest2d_dynamic_MI_nearest(test_data: torch.Tensor):
+    test_data, size, scale_factor, compare_outputs = test_data()
+
+    batch_size = torch.export.Dim("batch", min=0, max=1000)
+    input_height = torch.export.Dim("input_height", min=0, max=1000)
+    input_width = torch.export.Dim("input_width", min=0, max=1000)
+
+    dynamic_shapes = {"x": {0: batch_size, 2: input_height, 3: input_width}}
+
+    pipeline = TosaPipelineMI[input_t1](
+        UpsamplingNearest2d(size, scale_factor),
+        (test_data,),
+        aten_op,
+        exir_op=[],
+        dynamic_shapes=dynamic_shapes,
+    )
+    if not compare_outputs:
+        pipeline.pop_stage(-1)
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data_suite_dynamic)
+def test_upsample_nearest2d_dynamic_BI_nearest(test_data: torch.Tensor):
+    test_data, size, scale_factor, compare_outputs = test_data()
+
+    batch_size = torch.export.Dim("batch", min=0, max=2)
+    input_height = torch.export.Dim("input_height", min=0, max=8)
+    input_width = torch.export.Dim("input_width", min=0, max=8)
+
+    dynamic_shapes = {"x": {0: batch_size, 2: input_height, 3: input_width}}
+
+    pipeline = TosaPipelineBI[input_t1](
+        UpsamplingNearest2d(size, scale_factor),
+        (test_data,),
+        aten_op,
+        exir_op=[],
+        dynamic_shapes=dynamic_shapes,
+    )
+    if not compare_outputs:
+        pipeline.pop_stage(-1)
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data_suite_dynamic)
+def test_upsample_nearest2d_dynamic_MI_interpolate(test_data: torch.Tensor):
+    test_data, size, scale_factor, compare_outputs = test_data()
+
+    batch_size = torch.export.Dim("batch", min=0, max=2)
+    input_height = torch.export.Dim("input_height", min=4, max=8)
+    input_width = torch.export.Dim("input_width", min=3, max=8)
+
+    dynamic_shapes = {
+        "x": {
+            0: batch_size,
+            2: input_height,
+            3: input_width,
+        }
+    }
+
+    pipeline = TosaPipelineMI[input_t1](
+        Interpolate(size, scale_factor),
+        (test_data,),
+        aten_op,
+        exir_op=[],
+        dynamic_shapes=dynamic_shapes,
+    )
+    if not compare_outputs:
+        pipeline.pop_stage(-1)
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data_suite_dynamic)
+def test_upsample_nearest2d_dynamic_BI_interpolate(test_data: torch.Tensor):
+    test_data, size, scale_factor, compare_outputs = test_data()
+
+    batch_size = torch.export.Dim("batch", min=0, max=2)
+    input_height = torch.export.Dim("input_height", min=4, max=8)
+    input_width = torch.export.Dim("input_width", min=3, max=8)
+
+    dynamic_shapes = {
+        "x": {
+            0: batch_size,
+            2: input_height,
+            3: input_width,
+        }
+    }
+
+    pipeline = TosaPipelineBI[input_t1](
+        Interpolate(size, scale_factor),
+        (test_data,),
+        aten_op,
+        exir_op=[],
+        dynamic_shapes=dynamic_shapes,
+    )
+    if not compare_outputs:
+        pipeline.pop_stage(-1)
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data_suite_dynamic)
+def test_upsample_nearest2d_dynamic_MI_upsample(test_data: torch.Tensor):
+    test_data, size, scale_factor, compare_outputs = test_data()
+
+    batch_size = torch.export.Dim("batch", min=0, max=1000)
+    input_height = torch.export.Dim("input_height", min=0, max=1000)
+    input_width = torch.export.Dim("input_width", min=0, max=1000)
+
+    dynamic_shapes = {
+        "x": {
+            0: batch_size,
+            2: input_height,
+            3: input_width,
+        }
+    }
+
+    pipeline = TosaPipelineMI[input_t1](
+        Upsample(size, scale_factor),
+        (test_data,),
+        aten_op,
+        exir_op=[],
+        dynamic_shapes=dynamic_shapes,
+    )
+    if not compare_outputs:
+        pipeline.pop_stage(-1)
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data_suite_dynamic)
+def test_upsample_nearest2d_dynamic_BI_upsample(test_data: torch.Tensor):
+    test_data, size, scale_factor, compare_outputs = test_data()
+
+    batch_size = torch.export.Dim("batch", min=0, max=2)
+    input_height = torch.export.Dim("input_height", min=0, max=8)
+    input_width = torch.export.Dim("input_width", min=0, max=8)
+
+    dynamic_shapes = {
+        "x": {
+            0: batch_size,
+            2: input_height,
+            3: input_width,
+        }
+    }
+
+    pipeline = TosaPipelineBI[input_t1](
+        Upsample(size, scale_factor),
+        (test_data,),
+        aten_op,
+        exir_op=[],
+        dynamic_shapes=dynamic_shapes,
+    )
+    if not compare_outputs:
+        pipeline.pop_stage(-1)
+    pipeline.run()