NXP backend: Prohibit delegation of convolution with batch size != 1.

Neutron only supports batch == 1.

Author: Pop-korn

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

@@ -84,6 +84,10 @@ def _is_supported_in_IR(
             if weight_tensor.dtype not in [torch.float32, torch.int8, torch.uint8]:
                 return False
 
+        if node.args[0].meta["val"].shape[0] != 1:
+            # Only batch size 1 is supported on neutron.
+            return False
+
         return True
 
     Stride = Padding = Dilation = OutPadding = list[int]

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

@@ -124,12 +124,10 @@ def test_constant_pad_nd_conversion__format_less(input_shape, paddings):
 @pytest.mark.parametrize(
     "input_shape, paddings",
     [
-        pytest.param([2, 4, 6, 8], list(range(2)), id="4D, padding W"),
-        pytest.param([2, 4, 6, 8], list(range(4)), id="4D, padding H, W"),
-        pytest.param([2, 1, 6, 8], [1, 2, 3, 4, 2, 1], id="4D, padding C, H, W"),
-        pytest.param(
-            [2, 1, 6, 8], [1, 2, 3, 4, 2, 1, 5, 6], id="4D, padding N, C, H, W"
-        ),
+        pytest.param([1, 4, 6, 8], list(range(2)), id="4D, padding W"),
+        pytest.param([1, 4, 6, 8], list(range(4)), id="4D, padding H, W"),
+        pytest.param([1, 1, 6, 8], [1, 2, 3, 4, 2, 1], id="4D, padding C, H, W"),
+        # pytest.param([1, 1, 6, 8], [1, 2, 3, 4, 2, 1, 5, 6], id='4D, padding N, C, H, W'),  # Batch size must stay 0.
     ],
 )
 def test_constant_pad_nd_conversion__channels_first(input_shape, paddings):

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

@@ -215,18 +215,8 @@ def test_conv2d_quant_conversion(mocker, model: torch.nn.Module, input_shape):
 @pytest.mark.parametrize("stride", [1, 2])
 @pytest.mark.parametrize("dilation", [1, 2])
 @pytest.mark.parametrize("kernel_shape", [[1, 2], [3, 3], [4, 1]])
-@pytest.mark.parametrize(
-    "input_shape",
-    [
-        [1, 4, 12, 12],
-        [2, 3, 10, 15],
-        [11, 10, 9, 8],
-    ],
-    ids=lambda x: f"Input shape = {x}, groups = {x[1]}",
-)
-def test_conv2d_conversion__depthwise(
-    input_shape, stride, dilation, kernel_shape, mocker
-):
+def test_conv2d_conversion__depthwise(stride, dilation, kernel_shape, mocker):
+    input_shape = [1, 3, 12, 16]
     group = input_shape[1]
     edge_program = to_edge_program(
         Conv2dModule(
@@ -292,16 +282,8 @@ def test_conv2d_conversion__depthwise__quantized(
 
 
 @pytest.mark.parametrize("padding", [1, 2])
-@pytest.mark.parametrize(
-    "input_shape",
-    [
-        [1, 4, 12, 12],
-        [2, 3, 4, 5],
-        [11, 10, 9, 8],
-    ],
-    ids=lambda x: f"Input shape = {x}, groups = {x[1]}",
-)
-def test_conv2d_conversion__depthwise__padded(input_shape, padding, mocker):
+def test_conv2d_conversion__depthwise__padded(padding, mocker):
+    input_shape = [1, 3, 13, 15]
     group = input_shape[1]
     edge_program = to_edge_program(
         Conv2dModule(
@@ -377,7 +359,7 @@ def test_conv2d_conversion__separated(
     input_data = np.random.random(input_shape).astype(np.float32)
 
     # Note: The generic group convolution is not yet supported by Neutron Converter. Once supported, the
-    #  commented out code allows usuall testing flow for this test-case.
+    #  commented out code allows usual testing flow for this test-case.
 
     # spy = mocker.spy(ModelBuilder, 'finish')
 

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

@@ -70,8 +70,8 @@ def test_softmax_conversion__unknown_input_format(input_shape, dim: int):
 @pytest.mark.parametrize(
     "input_shape,dim",
     [
-        pytest.param((10, 4, 32, 32), 1, id="4D,dim=1"),
-        pytest.param((10, 4, 16, 16), -3, id="4D,dim=-3"),
+        pytest.param((1, 4, 32, 32), 1, id="4D,dim=1"),
+        pytest.param((1, 4, 16, 16), -3, id="4D,dim=-3"),
     ],
 )
 def test_softmax_conversion_channel_last(input_shape, dim: int):

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

@@ -90,8 +90,8 @@ def forward(self, x):
 
 
 def test__channels_first_to_2d(mocker):
-    input_shape = [2, 4, 7, 9]
-    new_shape = [12, 32]  # Mix up the dimensions for a thorough test.
+    input_shape = [1, 4, 7, 9]
+    new_shape = [6, 32]  # Mix up the dimensions for a thorough test.
 
     torch_model = ConvReshapeModule(channels=input_shape[1], new_shape=new_shape)
     edge_program = to_edge_program(torch_model, input_shape).exported_program()
@@ -113,7 +113,7 @@ def test__channels_first_to_2d(mocker):
 
 
 def test__channels_first_to_4d(mocker):
-    input_shape = [2, 4, 6, 8]
+    input_shape = [1, 8, 6, 8]
     new_shape = [7, 4, 2, 5]
 
     torch_model = ConvReshapeModule(channels=input_shape[1], new_shape=new_shape)
@@ -124,7 +124,10 @@ def test__channels_first_to_4d(mocker):
     converter_spy = mocker.spy(ModelBuilder, "finish")
 
     convert_run_compare(
-        edge_program, input_data, tflite_input_preprocess=ToNHWCPreprocess()
+        edge_program,
+        input_data,
+        tflite_input_preprocess=ToNHWCPreprocess(),
+        atol=2.0e-7,
     )
 
     tflite_model = converter_spy.spy_return
@@ -137,7 +140,7 @@ def test__channels_first_to_4d(mocker):
 
 def test__formatless_to_channels_first(mocker):
     input_shape = [12, 32]
-    new_shape = [2, 4, 6, 8]  # Mix up the dimensions for a thorough test.
+    new_shape = [1, 4, 12, 8]  # Mix up the dimensions for a thorough test.
 
     torch_model = FormatlessToChannelsFirstModule(
         channels=new_shape[1], new_shape=new_shape
@@ -149,7 +152,10 @@ def test__formatless_to_channels_first(mocker):
     converter_spy = mocker.spy(ModelBuilder, "finish")
 
     convert_run_compare(
-        edge_program, input_data, tflite_output_preprocess=ToNCHWPreprocess()
+        edge_program,
+        input_data,
+        tflite_output_preprocess=ToNCHWPreprocess(),
+        atol=2.0e-7,
     )
 
     tflite_model = converter_spy.spy_return
@@ -162,7 +168,7 @@ def test__formatless_to_channels_first(mocker):
 
 def test__formatless_to_formatless(mocker):
     input_shape = [12, 32]
-    new_shape = [2, 4, 6, 8]
+    new_shape = [1, 4, 6, 16]
 
     torch_model = FormatlessToFormatlessModule(new_shape=new_shape)
     edge_program = to_edge_program(torch_model, input_shape).exported_program()