Update for eIQ Neutron SDK 3.1.2

Author: irtrukhina

backends/nxp/backend/ir/converter/node_converters/ops_converters/softmax_converter.py

@@ -59,63 +59,31 @@ def _is_supported_on_target(
         parameters_mapping: dict[str, Parameter],
         custom_delegation_options: CustomDelegationOptions,
     ) -> bool:
-        if neutron_target_spec.use_new_flow_neutron_c:
-            """New flow: Hardware constraints for the new flow:
-            1. Input and Output must be INT8/UINT8
-            2. Channels <= 2040
-            3. Total spatial size <= 4096
-            4. Total size (channels * spatial_size) <= 524288
-            """
-            # Constraint 1: Input and Output must be INT8/UINT8.
-            supported_types = [torch.int8, torch.uint8]
-            if not NodeConverter.uses_quantization_type_for_io(
-                node, supported_types, [0], [0]
-            ):
-                return False
-
-            # Constraint 2: Channel size limit
-            channels = SoftmaxConverter._get_channels(node)
-            if channels > 2040:
-                return False
-
-            # Constraint 3: Spatial size limit
-            total_spatial_size = SoftmaxConverter._get_total_spatial_size(node)
-            if total_spatial_size > 4096:
-                return False
-
-            # Constraint 4: Total processing size limit
-            if channels * total_spatial_size > 524288:
-                return False
-
-            return True
-
-        """Old flow. Hardware constraints for the old flow:
-        1. Input rank must be >= 2 (Neutron does not support 1D)
-        2. Channels < 4096 / num_pipes * 4
+        """New flow: Hardware constraints for the new flow:
+        1. Input and Output must be INT8/UINT8
+        2. Channels <= 2040
         3. Total spatial size (N*H*W) <= 4096
-        4. (channels * spatial_size) / num_macs <= 65536
+        4. Total size (channels * spatial_size) <= 524288
         """
-        input_shape = node.meta["val"].shape
-
-        # Constraint 1: Neutron does not support 1D SoftMax
-        if len(input_shape) == 1:
+        # Constraint 1: Input and Output must be INT8/UINT8.
+        supported_types = [torch.int8, torch.uint8]
+        if not NodeConverter.uses_quantization_type_for_io(
+            node, supported_types, [0], [0]
+        ):
             return False
 
-        num_macs = neutron_target_spec.get_num_macs()
-        num_pipes = neutron_target_spec.get_num_pipes()
-        channels = SoftmaxConverter._get_channels(node)
-        total_spatial_size = SoftmaxConverter._get_total_spatial_size(node)
-
         # Constraint 2: Channel size limit
-        if channels >= 4096 / num_pipes * 4:
+        channels = SoftmaxConverter._get_channels(node)
+        if channels > 2040:
             return False
 
         # Constraint 3: Spatial size limit
+        total_spatial_size = SoftmaxConverter._get_total_spatial_size(node)
         if total_spatial_size > 4096:
             return False
 
         # Constraint 4: Total processing size limit
-        if channels * total_spatial_size / num_macs > 65536:
+        if channels * total_spatial_size > 524288:
             return False
 
         return True

backends/nxp/tests/ir/converter/node_converter/test_softmax_converter.py

@@ -7,16 +7,8 @@
 import pytest
 import torch
 
-from executorch.backends.nxp.backend.edge_program_converter import (
-    EdgeProgramToIRConverter,
-)
 from executorch.backends.nxp.tests.executorch_pipeline import to_quantized_edge_program
-from executorch.backends.nxp.tests.executors import (
-    convert_run_compare,
-    graph_contains_any_of_ops,
-    ToChannelFirstPreprocess,
-    ToChannelLastPreprocess,
-)
+from executorch.backends.nxp.tests.executors import graph_contains_any_of_ops
 
 from executorch.backends.nxp.tests.graph_verifier import DetailedGraphVerifier
 
@@ -55,164 +47,7 @@ def assert_softmax_not_delegated(graph):
     assert graph_contains_any_of_ops(graph, [Softmax])
 
 
-def random_input_data(input_shape):
-    return (np.random.random(input_shape).astype(np.float32) * 256.0 - 128.0).astype(
-        np.int8
-    )
-
-
-@pytest.mark.parametrize(
-    "input_shape, dim",
-    [
-        # Dim must always be the last dimension, which must be a multiple of 8 (num_macs).
-        pytest.param((4096, 128), -1, id="2D_total_size_limit"),
-        pytest.param((5, 8), -1, id="2D_dim_-1"),
-        pytest.param((5, 8), 1, id="2D_dim_1"),
-        pytest.param((4096, 8), -1, id="2D_WxH_limit"),
-        pytest.param((2, 2048 - 8), -1, id="2D_channels_limit"),
-        pytest.param((5, 4, 8), -1, id="3D_dim_-1"),
-        pytest.param((4096, 1, 8), -1, id="3D_WxH_limit"),
-        pytest.param((5, 4, 3, 8), -1, id="4D_dim_-1"),
-        pytest.param((1, 64, 64, 8), -1, id="4D_WxH_limit"),
-        pytest.param((64, 1, 64, 128), -1, id="4D_total_size_limit"),
-        pytest.param((5, 4, 3, 2, 8), -1, id="5D_dim_-1"),
-    ],
-)
-def test_softmax_delegation(input_shape, dim: int, mocker):
-    model = SoftmaxModule(dim)
-
-    converter_spy = mocker.spy(EdgeProgramToIRConverter, "convert_program")
-    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
-
-    assert_softmax_delegated(delegated_ep.graph)
-
-    # Verify correct behavior of the converted NeutronIR model.
-    intermediate_ep = converter_spy.call_args.args[1]
-    neutron_ir_model, _ = converter_spy.spy_return
-    input_data = random_input_data(input_shape)
-
-    # Make sure the tested program contains the `softmax`, and its input has the expected rank.
-    nodes = list(intermediate_ep.graph.nodes)
-    assert nodes[2].target == Softmax
-    assert len(nodes[2].args[0].meta["val"].shape) == len(input_shape)
-
-    convert_run_compare(
-        intermediate_ep,
-        tfl_model=neutron_ir_model,
-        input_data=input_data,
-    )
-
-
-@pytest.mark.parametrize(
-    "input_shape,dim",
-    [
-        # `dim` must be the second dimension, which must be a multiple of 8 (num_macs).
-        pytest.param((1, 8, 2, 3), 1, id="4D_dim_1"),
-        pytest.param((1, 8, 64, 64), 1, id="4D_WxH_limit"),
-        pytest.param((64, 128, 1, 64), -3, id="4D_dim_-3_total_size_limit"),
-    ],
-)
-def test_softmax_delegation__channel_first(input_shape, dim: int, mocker):
-    model = ConvSoftmaxModule(dim, input_shape[1])
-
-    converter_spy = mocker.spy(EdgeProgramToIRConverter, "convert_program")
-    delegated_ep = to_quantized_edge_program(
-        model, input_shape, use_neutron_for_format_conversion=False
-    ).exported_program()
-
-    assert_softmax_delegated(delegated_ep.graph)
-
-    # Verify correct behavior of the converted NeutronIR model.
-    intermediate_ep = converter_spy.call_args.args[1]
-    neutron_ir_model, _ = converter_spy.spy_return
-    input_data = random_input_data(input_shape)
-
-    # Make sure the tested program contains the `softmax`.
-    assert graph_contains_any_of_ops(intermediate_ep.graph, [Softmax])
-
-    convert_run_compare(
-        intermediate_ep,
-        tfl_model=neutron_ir_model,
-        input_data=input_data,
-        tflite_input_preprocess=ToChannelLastPreprocess(),
-        tflite_output_preprocess=ToChannelFirstPreprocess(),
-    )
-
-
-@pytest.mark.parametrize(
-    "input_shape,dim",
-    [
-        # `dim` is not the last dimension.
-        pytest.param((10, 32), 0, id="2D_dim_0"),
-        pytest.param((10, 32, 32), 1, id="3D_dim_1"),
-        pytest.param((10, 32, 32, 8), 2, id="4D_dim_2"),
-        pytest.param((10, 32, 32, 8, 8), 3, id="5D_dim_3"),
-        pytest.param((10, 32, 32, 8, 8), 2, id="5D_dim_2"),
-    ],
-)
-def test_softmax_delegation__unsupported_dims(input_shape, dim: int):
-    model = SoftmaxModule(dim)
-    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
-    assert_softmax_not_delegated(delegated_ep.graph)
-
-
-@pytest.mark.parametrize(
-    "input_shape,dim",
-    [
-        # `dim` is not the second dimension.
-        pytest.param((10, 32, 32, 8), 2, id="dim_2"),
-        pytest.param((10, 32, 32, 8), -1, id="dim_-1"),
-        pytest.param((10, 32, 32, 8), 3, id="dim_3"),
-    ],
-)
-def test_softmax_delegation__unsupported_dims__channels_first(input_shape, dim: int):
-    model = SoftmaxModule(dim)
-    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
-    assert_softmax_not_delegated(delegated_ep.graph)
-
-
-@pytest.mark.parametrize(
-    "input_shape,dim",
-    [
-        pytest.param((4096 + 1, 8), -1, id="2D_WxH_exceeded"),
-        pytest.param((4096, 2, 8), -1, id="3D_WxH_exceeded"),
-        pytest.param((2, 64, 64, 8), -1, id="4D_WxH_exceeded"),
-        pytest.param((1, 2048), -1, id="2D_channels_exceeded"),
-        pytest.param((4096, 128 + 8), -1, id="2D_total_size_exceeded"),
-        pytest.param((64, 1, 64, 128 + 8), -1, id="4D_total_size_exceeded"),
-    ],
-)
-def test_softmax_delegation__unsupported_dimension_sizes(input_shape, dim: int):
-    model = SoftmaxModule(dim)
-    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
-    assert_softmax_not_delegated(delegated_ep.graph)
-
-
-@pytest.mark.parametrize(
-    "input_shape,dim",
-    [
-        pytest.param((2, 8, 64, 64), -1, id="4D_WxH_exceeded"),
-        pytest.param((64, 128 + 8, 1, 64), -1, id="4D_total_size_exceeded"),
-    ],
-)
-def test_softmax_delegation__unsupported_dimension_sizes__channels_first(
-    input_shape, dim: int
-):
-    model = ConvSoftmaxModule(dim, input_shape[1])
-    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
-    assert_softmax_not_delegated(delegated_ep.graph)
-
-
-def test_softmax_delegation__1d():
-    input_shape = (8,)
-    dim = 0
-
-    model = SoftmaxModule(dim)
-    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
-    assert_softmax_not_delegated(delegated_ep.graph)
-
-
-class TestSoftmaxNewNeutronFlow:
+class TestSoftmax:
     @pytest.mark.parametrize(
         "input_shape, dim",
         [
@@ -238,7 +73,6 @@ def test__basic_nsys_inference(self, mocker, input_shape, dim):
             model,
             input_shape,
             graph_verifier,
-            use_new_flow_neutron_c=True,
             output_comparator=output_comparator,
         )
 
@@ -254,9 +88,7 @@ def test__basic_nsys_inference(self, mocker, input_shape, dim):
     )
     def test__limits(self, input_shape, dim, mocker):
         model = SoftmaxModule(dim)
-        delegated_ep = to_quantized_edge_program(
-            model, input_shape, use_new_flow_neutron_c=True
-        ).exported_program()
+        delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
 
         # Make sure the `softmax` was delegated.
         assert_softmax_delegated(delegated_ep.graph)
@@ -273,9 +105,7 @@ def test__limits(self, input_shape, dim, mocker):
     )
     def test__limits_exceeded(self, input_shape, dim):
         model = SoftmaxModule(dim)
-        delegated_ep = to_quantized_edge_program(
-            model, input_shape, use_new_flow_neutron_c=True
-        ).exported_program()
+        delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
 
         # Make sure the `softmax` was NOT delegated.