NXP backend: Conversion and quantization of aten.view

Author: StrycekSimon

backends/nxp/quantizer/neutron_quantizer.py

@@ -25,6 +25,7 @@
     ReluPattern,
     ReshapePattern,
     SoftMaxPattern,
+    ViewPattern,
 )
 from executorch.backends.nxp.quantizer.utils import (
     find_sequential_partitions_aten,
@@ -200,6 +201,7 @@ def __init__(self):
                 NeutronAtenQuantizer(ReluPattern(), static_qconfig),
                 NeutronAtenQuantizer(ReluInPlacePattern(), static_qconfig),
                 NeutronAtenQuantizer(AvgPoolPattern(), static_qconfig),
+                NeutronAtenQuantizer(ViewPattern(), static_qconfig),
             ]
         )
 

backends/nxp/quantizer/patterns.py

@@ -307,6 +307,15 @@ def partition_types(self):
         return [torch.ops.aten.reshape.default]
 
 
+class ViewPattern(SharedSpecPattern):
+    """
+    Quantizer for View operator.
+    """
+
+    def partition_types(self):
+        return [torch.ops.aten.view.default]
+
+
 class SoftMaxPattern(QuantizationPattern):
     """
     Quantizer for Softmax operator.

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

@@ -7,13 +7,7 @@
 import pytest
 import torch
 
-from executorch.backends.nxp.backend.edge_program_converter import (
-    EdgeProgramToIRConverter,
-)
-from executorch.backends.nxp.tests.executorch_pipeline import (
-    to_edge_program,
-    to_quantized_edge_program,
-)
+from executorch.backends.nxp.tests.executorch_pipeline import to_edge_program
 from executorch.backends.nxp.tests.executors import (
     convert_run_compare,
     ToNCHWPreprocess,
@@ -22,9 +16,7 @@
 from executorch.backends.nxp.tests.models import (
     ConstantPadNDConvModule,
     ConstantPadNDModule,
-    Conv2dConstantPadNDModule,
 )
-from torch.export import ExportedProgram
 
 
 @pytest.fixture(autouse=True)
@@ -47,37 +39,6 @@ def test_constant_pad_nd_conversion__specific_constant(constant):
     convert_run_compare(edge_program, input_data)
 
 
-@pytest.mark.parametrize("constant", [0.0, 67.28, 42.0, -13.37])
-@pytest.mark.skip(reason="Neutron Converter does not fully convert for NPU")
-def test_constant_pad_nd_quant_conversion__specific_constant(mocker, constant):
-    input_shape = (2, 4, 12, 12)
-    paddings = (2, 2, 2, 2)
-
-    converter_spy = mocker.spy(EdgeProgramToIRConverter, "convert_program")
-
-    # Run conversion
-    _ = to_quantized_edge_program(
-        Conv2dConstantPadNDModule(paddings, constant), input_shape
-    )
-
-    # Capture generated model
-    tflite_flatbuffers_model, io_formats = converter_spy.spy_return
-
-    # Capture converted program
-    edge_program: ExportedProgram = converter_spy.call_args.args[1]
-
-    input_data = (np.random.random(input_shape).astype(np.float32) * 50).astype(np.int8)
-
-    convert_run_compare(
-        edge_program,
-        input_data,
-        tfl_model=tflite_flatbuffers_model,
-        atol=1.0,
-        tflite_input_preprocess=ToNHWCPreprocess(),
-        tflite_output_preprocess=ToNCHWPreprocess(),
-    )
-
-
 def test_constant_pad_nd_conversion__default_constant():
     input_shape = [2, 4, 6, 8]
     paddings = [1, 2, 3, 4]

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

@@ -89,6 +89,24 @@ def forward(self, x):
         return x
 
 
+class ConvLinearViewModule(torch.nn.Module):
+    def __init__(self, channels: int, channels_view_out: int):
+        super().__init__()
+        self.conv = nn.Conv2d(channels, channels, 3, 2)
+        self.linear = nn.Linear(channels_view_out, 32, bias=True)
+        self.channels_view_out = channels_view_out
+        self.avg_pool = nn.AvgPool2d(1)
+        self.relu = nn.ReLU()
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.relu(x)
+        x = self.avg_pool(x)
+        x = x.view(-1, self.channels_view_out)
+        x = self.linear(x)
+        return 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.
@@ -205,19 +223,20 @@ def test_view_copy_w_linear_quant_conversion(mocker, input_shape, new_shape):
 
 
 @pytest.mark.parametrize(
-    "input_shape, new_shape",
+    "input_shape, channels_view_out",
     [
-        pytest.param((1, 4, 16, 16), (50, 18), id="4D, batch_size=1"),
-        pytest.param((10, 4, 16, 16), (500, 18), id="4D, , batch_size=10"),
+        pytest.param((1, 4, 16, 16), 196, id="4D"),
     ],
 )
-@pytest.mark.skip(reason="Neutron Converter does not fully convert for NPU")
-def test_view_copy_w_conv_quant_conversion(mocker, input_shape, new_shape):
+def test_view_w_conv_linear_quant_conversion(mocker, input_shape, channels_view_out):
     converter_spy = mocker.spy(EdgeProgramToIRConverter, "convert_program")
 
     # Run conversion
     _ = to_quantized_edge_program(
-        ConvReshapeModule(channels=input_shape[1], new_shape=new_shape), input_shape
+        ConvLinearViewModule(
+            channels=input_shape[1], channels_view_out=channels_view_out
+        ),
+        input_shape,
     )
 
     # Capture generated model