Add test case to export, quantize and lower vision encoder model for ET

[ghstack-poisoned]

Author: tarun292

examples/models/llama3_2_vision/vision_encoder/model.py

@@ -15,7 +15,7 @@
     replace_tiled_token_positional_embedding,
 )
 from torchtune.models.llama3_2_vision._component_builders import llama3_2_vision_encoder
-
+from executorch.extension.llm.modules.attention import replace_mha_with_inference_mha, replace_sdpa_with_custom_op
 
 @dataclass
 class VisionEncoderConfig:
@@ -47,7 +47,7 @@ class VisionEncoderConfig:
 
 
 class FlamingoVisionEncoderModel(EagerModelBase):
-    def __init__(self, config: Optional[VisionEncoderConfig] = None):
+    def __init__(self, config: Optional[VisionEncoderConfig] = None, enable_source_transforms = True):
         super().__init__()
         if config is None:
             config = demo_config
@@ -64,8 +64,8 @@ def __init__(self, config: Optional[VisionEncoderConfig] = None):
             max_num_tiles=config.max_num_tiles,
             in_channels=config.in_channels,
         )
-        self.model = replace_tile_positional_embedding(self.model)
-        self.model = replace_tiled_token_positional_embedding(self.model)
+        if enable_source_transforms:
+            self.source_transofrm()
         self.image = torch.randn(
             1, 1, 4, 3, self.config.tile_size, self.config.tile_size
         )
@@ -75,6 +75,12 @@ def __init__(self, config: Optional[VisionEncoderConfig] = None):
             self.aspect_ratio,
         )
 
+    def source_transofrm(self):
+        self.model = replace_tile_positional_embedding(self.model)
+        self.model = replace_tiled_token_positional_embedding(self.model)
+        self.model = replace_mha_with_inference_mha(self.model)
+        self.model = replace_sdpa_with_custom_op(self.model)
+
     def get_eager_model(self, **kwargs):
         return self.model
 

examples/models/llama3_2_vision/vision_encoder/test/test_vision_encoder.py

@@ -16,13 +16,56 @@
     FlamingoVisionEncoderModel,
 )
 from torch.testing import assert_close
-
+from executorch.exir import to_edge, to_edge_transform_and_lower, EdgeCompileConfig
+from torch._inductor.package import package_aoti
+from torch.nn.attention import SDPBackend
+from torch.ao.quantization.quantize_pt2e import convert_pt2e, prepare_pt2e
+from torch.ao.quantization.quantizer.xnnpack_quantizer import (
+    get_symmetric_quantization_config,
+    XNNPACKQuantizer,
+)
+from executorch.backends.transforms.duplicate_dynamic_quant_chain import (
+    DuplicateDynamicQuantChainPass
+)
+from executorch.backends.xnnpack.partition.xnnpack_partitioner import (
+                    XnnpackDynamicallyQuantizedPartitioner,
+)
 
 class FlamingoVisionEncoderTest(unittest.TestCase):
     def setUp(self) -> None:
         super().setUp()
 
-    def test_flamingo_vision_encoder(self) -> None:
+    def test_flamingo_vision_encoder_et(self) -> None:
+        with torch.no_grad():
+            vision_model = FlamingoVisionEncoderModel(enable_source_transforms=False)
+            encoder_no_source_transform_outputs = vision_model.model.forward(*vision_model.get_example_inputs())
+            vision_model.source_transofrm()
+            encoder = vision_model.model
+            encoder_source_transform_outputs = encoder.forward(*vision_model.get_example_inputs())
+            assert_close(encoder_source_transform_outputs, encoder_no_source_transform_outputs)
+
+            with torch.nn.attention.sdpa_kernel([SDPBackend.MATH]), torch.no_grad(), tempfile.TemporaryDirectory() as tmpdir:
+                training_output = torch.export.export_for_training(encoder, vision_model.get_example_inputs(), dynamic_shapes=vision_model.get_dynamic_shapes())
+                assert_close(encoder(*vision_model.get_example_inputs()), training_output.module()(*vision_model.get_example_inputs()))
+
+                dynamic_quantizer = XNNPACKQuantizer()
+                operator_config_dynamic = get_symmetric_quantization_config(
+                    is_per_channel=True, is_dynamic=True
+                )
+                dynamic_quantizer.set_global(operator_config_dynamic)
+                prepare = prepare_pt2e(training_output.module(), dynamic_quantizer)
+                prepare(*vision_model.get_example_inputs())
+                convert = convert_pt2e(prepare)
+                DuplicateDynamicQuantChainPass()(convert)
+
+                export_output = torch.export.export(convert, vision_model.get_example_inputs(), dynamic_shapes=vision_model.get_dynamic_shapes())
+
+                edge = to_edge_transform_and_lower(export_output, partitioner=[
+                    XnnpackDynamicallyQuantizedPartitioner(),
+                ], compile_config=EdgeCompileConfig(_check_ir_validity=False))
+                edge.to_executorch()
+
+    def test_flamingo_vision_encoder_aoti(self) -> None:
         model = FlamingoVisionEncoderModel()
         encoder = model.model
         eager_res = encoder.forward(*model.get_example_inputs())