Merge branch 'main' into baris_mletorch-1918_layer_test_DeepSeek_R1_Distill_Qwen_1.5B

Author: bdemirb

backends/arm/_passes/normalize_while_initial_args_pass.py

@@ -62,7 +62,7 @@ def _connect_to_output(
                     (placeholder,),
                 )
                 cloned_placeholders.append(clone)
-                clone.meta = placeholder.meta.copy()
+                clone.meta = placeholder.meta
         output_node = body_module.graph.output_node()
         output_values = output_node.args[0]
         if not isinstance(output_values, tuple):

backends/arm/public_api_manifests/api_manifest_running.toml

@@ -62,7 +62,7 @@ signature = "EthosUPartitioner.register_custom_partition_op(self, op: torch._ops
 
 [python.EthosUQuantizer]
 kind = "class"
-signature = "EthosUQuantizer(compile_spec: 'EthosUCompileSpec', use_composable_quantizer: 'bool' = True) -> 'None'"
+signature = "EthosUQuantizer(compile_spec: 'EthosUCompileSpec', use_composable_quantizer: 'bool' = False) -> 'None'"
 
 [python.EthosUQuantizer.annotate]
 kind = "function"
@@ -150,7 +150,7 @@ signature = "VgfPartitioner.register_custom_partition_op(self, op: torch._ops.Op
 
 [python.VgfQuantizer]
 kind = "class"
-signature = "VgfQuantizer(compile_spec: 'VgfCompileSpec', use_composable_quantizer: 'bool' = True) -> 'None'"
+signature = "VgfQuantizer(compile_spec: 'VgfCompileSpec', use_composable_quantizer: 'bool' = False) -> 'None'"
 
 [python.VgfQuantizer.annotate]
 kind = "function"

backends/arm/quantizer/arm_quantizer.py

@@ -493,23 +493,21 @@ class TOSAQuantizer(Quantizer):
     """Manage quantization annotations for TOSA-compatible backends.
 
     .. warning::
-        The composable quantizer is now the default implementation. Setting
-        ``use_composable_quantizer=False`` is deprecated and will be removed in
-        two minor releases.
+        Setting ``use_composable_quantizer=True`` enables an experimental API
+        surface that may change without notice.
 
     """
 
     def __init__(
         self,
         compile_spec_or_tosa_spec,
-        use_composable_quantizer: bool = True,
+        use_composable_quantizer: bool = False,
     ) -> None:
         """Create a TOSA quantizer from a TOSA spec or Arm compile spec.
 
         .. warning::
-            The composable quantizer is now the default implementation.
-            Setting ``use_composable_quantizer=False`` is deprecated and will
-            be removed in two minor releases.
+            Setting ``use_composable_quantizer=True`` enables an experimental
+            API surface that may change without notice.
 
         """
         self.use_composable_quantizer = use_composable_quantizer
@@ -521,45 +519,10 @@ def __init__(
             self.quantizer = _TOSAQuantizerV2(compile_spec_or_tosa_spec)
         else:
             logger.info(
-                "Using deprecated legacy quantizer implementation in the arm backend. Setting use_composable_quantizer=False will be removed in two minor releases. See https://github.com/pytorch/executorch/issues/17701"
+                "Using default quantizer in the arm backend. This quantizer is planned to be replaced by the composable quantizer implementation in the future, see https://github.com/pytorch/executorch/issues/17701"
             )
             self.quantizer = _TOSAQuantizerV1(compile_spec_or_tosa_spec)
 
-    @staticmethod
-    def _validate_optional_quantization_config(
-        config_name: str, value: object, value_description: str = "value"
-    ) -> None:
-        if value is not None and not isinstance(value, QuantizationConfig):
-            raise TypeError(
-                f"{config_name} {value_description} must be "
-                "QuantizationConfig or None, "
-                f"got {type(value).__name__}."
-            )
-
-    @staticmethod
-    def _validate_config_dict(
-        config_name: str,
-        value: object,
-        is_valid_key: Callable[[object], bool],
-        key_description: str,
-    ) -> Dict[Any, Optional[QuantizationConfig]]:
-        if not isinstance(value, dict):
-            raise TypeError(
-                f"{config_name} must be a dict, got {type(value).__name__}."
-            )
-
-        for key, quantization_config in value.items():
-            if not is_valid_key(key):
-                raise TypeError(
-                    f"{config_name} keys must be {key_description}, "
-                    f"got {type(key).__name__}."
-                )
-            TOSAQuantizer._validate_optional_quantization_config(
-                config_name, quantization_config, "values"
-            )
-
-        return value
-
     @property
     def tosa_spec(self):
         """Return the TOSA specification used by the active quantizer."""
@@ -577,11 +540,12 @@ def global_config(self):
 
     @global_config.setter
     def global_config(self, value: Optional[QuantizationConfig]) -> None:
-        self._validate_optional_quantization_config("global_config", value)
         if isinstance(self.quantizer, _TOSAQuantizerV1):
             self.quantizer.global_config = value
         else:
-            self.quantizer.set_global(value)
+            raise NotImplementedError(
+                "Composable quantizer does not allow setting global_config directly. Please use set_global() instead."
+            )
 
     @property
     def io_config(self):
@@ -595,12 +559,12 @@ def io_config(self):
 
     @io_config.setter
     def io_config(self, value: Optional[QuantizationConfig]) -> None:
-        self._validate_optional_quantization_config("io_config", value)
         if isinstance(self.quantizer, _TOSAQuantizerV1):
             self.quantizer.io_config = value
         else:
-            self.quantizer.clear_io_config()
-            self.quantizer.set_io(value)
+            raise NotImplementedError(
+                "Composable quantizer does not allow setting io_config directly. Please use set_io() instead."
+            )
 
     @property
     def module_type_config(self):
@@ -616,18 +580,12 @@ def module_type_config(self):
     def module_type_config(
         self, value: Dict[Callable, Optional[QuantizationConfig]]
     ) -> None:
-        module_type_config = self._validate_config_dict(
-            "module_type_config",
-            value,
-            callable,
-            "callable",
-        )
         if isinstance(self.quantizer, _TOSAQuantizerV1):
-            self.quantizer.module_type_config = module_type_config
+            self.quantizer.module_type_config = value
         else:
-            self.quantizer.clear_module_type_config()
-            for module_type, quantization_config in module_type_config.items():
-                self.quantizer.set_module_type(module_type, quantization_config)
+            raise NotImplementedError(
+                "Composable quantizer does not allow setting module_type_config directly. Please use set_module_type() instead."
+            )
 
     @property
     def module_name_config(self):
@@ -643,18 +601,12 @@ def module_name_config(self):
     def module_name_config(
         self, value: Dict[str, Optional[QuantizationConfig]]
     ) -> None:
-        module_name_config = self._validate_config_dict(
-            "module_name_config",
-            value,
-            lambda key: isinstance(key, str),
-            "str",
-        )
         if isinstance(self.quantizer, _TOSAQuantizerV1):
-            self.quantizer.module_name_config = module_name_config
+            self.quantizer.module_name_config = value
         else:
-            self.quantizer.clear_module_name_config()
-            for module_name, quantization_config in module_name_config.items():
-                self.quantizer.set_module_name(module_name, quantization_config)
+            raise NotImplementedError(
+                "Composable quantizer does not allow setting module_name_config directly. Please use set_module_name() instead."
+            )
 
     def set_global(
         self, quantization_config: Optional[QuantizationConfig]
@@ -1179,30 +1131,6 @@ def quantizers(self, value: List[Quantizer]) -> None:
         """Update quantizers without accessing self._quantizers directly."""
         self._quantizers = value
 
-    def _remove_quantizers_by_node_finder_type(
-        self, node_finder_types: type[NodeFinder] | tuple[type[NodeFinder], ...]
-    ) -> None:
-        self._quantizers = [
-            quantizer
-            for quantizer in self._quantizers
-            if not (
-                isinstance(quantizer, PatternQuantizer)
-                and isinstance(quantizer.node_finder, node_finder_types)
-            )
-        ]
-
-    def clear_module_type_config(self) -> _TOSAQuantizerV2:
-        self._remove_quantizers_by_node_finder_type(ModuleTypeNodeFinder)
-        return self
-
-    def clear_module_name_config(self) -> _TOSAQuantizerV2:
-        self._remove_quantizers_by_node_finder_type(ModuleNameNodeFinder)
-        return self
-
-    def clear_io_config(self) -> _TOSAQuantizerV2:
-        self._remove_quantizers_by_node_finder_type((InputNodeFinder, OutputNodeFinder))
-        return self
-
     def annotate(self, model):
         reporter = QuantizerReporter(self.quantizers, "FINAL QUANTIZATION REPORT")
         model = super().annotate(model)
@@ -1356,25 +1284,20 @@ class EthosUQuantizer(TOSAQuantizer):
     """Quantizer supported by the Arm Ethos-U backend.
 
     .. warning::
-        The composable quantizer is now the default implementation. Setting
-        ``use_composable_quantizer=False`` is deprecated and will be removed in
-        two minor releases.
+        Setting ``use_composable_quantizer=True`` enables an experimental API
+        surface that may change without notice.
 
     Args:
         compile_spec (EthosUCompileSpec): Backend compile specification for
             Ethos-U targets.
-        use_composable_quantizer (bool): Whether to use the composable
-            quantizer implementation. Setting this to ``False`` is deprecated
-            and will be removed in two minor releases. See
-            [issue #17701](https://github.com/pytorch/executorch/issues/17701)
-            for details.
+        use_composable_quantizer (bool): Whether to use the composable quantizer implementation. See https://github.com/pytorch/executorch/issues/17701" for details.
 
     """
 
     def __init__(
         self,
         compile_spec: EthosUCompileSpec,
-        use_composable_quantizer: bool = True,
+        use_composable_quantizer: bool = False,
     ) -> None:
         super().__init__(compile_spec, use_composable_quantizer)
 
@@ -1383,24 +1306,19 @@ class VgfQuantizer(TOSAQuantizer):
     """Quantizer supported by the Arm Vgf backend.
 
     .. warning::
-        The composable quantizer is now the default implementation. Setting
-        ``use_composable_quantizer=False`` is deprecated and will be removed in
-        two minor releases.
+        Setting ``use_composable_quantizer=True`` enables an experimental API
+        surface that may change without notice.
 
     Args:
         compile_spec (VgfCompileSpec): Backend compile specification for Vgf
             targets.
-        use_composable_quantizer (bool): Whether to use the composable
-            quantizer implementation. Setting this to ``False`` is deprecated
-            and will be removed in two minor releases. See
-            [issue #17701](https://github.com/pytorch/executorch/issues/17701)
-            for details.
+        use_composable_quantizer (bool): Whether to use the composable quantizer implementation. See https://github.com/pytorch/executorch/issues/17701" for details.
 
     """
 
     def __init__(
         self,
         compile_spec: VgfCompileSpec,
-        use_composable_quantizer: bool = True,
+        use_composable_quantizer: bool = False,
     ) -> None:
         super().__init__(compile_spec, use_composable_quantizer)

backends/arm/quantizer/arm_quantizer_utils.py

@@ -598,11 +598,14 @@ def _model_has_uint8_io(self, model: torch.fx.GraphModule) -> bool:
             self._is_uint8_quantized_io_boundary(node) for node in model.graph.nodes
         )
 
-    def _get_shared_clique(self, root_node: Node) -> tuple[set[Node], list[Any], bool]:
+    def _get_shared_clique(
+        self, root_node: Node
+    ) -> tuple[set[Node], list[Any], bool, bool]:
         shared_nodes = set()
         bfs_queue = [root_node]
         adjacent_qspecs: list[Any] = []
         touches_quantized_io = False
+        touches_uint8_quantized_io = False
 
         while bfs_queue:
             node = bfs_queue.pop(0)
@@ -612,13 +615,24 @@ def _get_shared_clique(self, root_node: Node) -> tuple[set[Node], list[Any], boo
                 self._maybe_enqueue_shared_node(input_node, shared_nodes, bfs_queue)
                 self._append_output_qspec(input_node, adjacent_qspecs)
                 touches_quantized_io |= self._is_quantized_io_boundary(input_node)
+                touches_uint8_quantized_io |= self._is_uint8_quantized_io_boundary(
+                    input_node
+                )
 
             for output_node in node.users.keys():
                 self._maybe_enqueue_shared_node(output_node, shared_nodes, bfs_queue)
                 self._append_input_qspec(output_node, node, adjacent_qspecs)
                 touches_quantized_io |= self._is_quantized_io_boundary(output_node)
+                touches_uint8_quantized_io |= self._is_uint8_quantized_io_boundary(
+                    output_node
+                )
 
-        return shared_nodes, adjacent_qspecs, touches_quantized_io
+        return (
+            shared_nodes,
+            adjacent_qspecs,
+            touches_quantized_io,
+            touches_uint8_quantized_io,
+        )
 
     def _should_skip_while_shared_qspec(self, node: Node) -> bool:
         return node.target == torch.ops.higher_order.while_loop and bool(
@@ -673,9 +687,12 @@ def _annotate_shared_cluster(self, root_node: Node) -> None:
             )
             return
 
-        shared_nodes, adjacent_qspecs, touches_quantized_io = self._get_shared_clique(
-            root_node
-        )
+        (
+            shared_nodes,
+            adjacent_qspecs,
+            touches_quantized_io,
+            touches_uint8_quantized_io,
+        ) = self._get_shared_clique(root_node)
 
         # If there is no neighbor qspec to propagate but the cluster sits on the
         # quantized I/O boundary (e.g. a state-passthrough cat whose only neighbors
@@ -695,6 +712,15 @@ def _annotate_shared_cluster(self, root_node: Node) -> None:
         node_order = {node: index for index, node in enumerate(root_node.graph.nodes)}
         ordered_nodes = sorted(shared_nodes, key=lambda node: node_order.get(node, 0))
 
+        if touches_uint8_quantized_io and any(
+            node.target in self._UINT8_IO_BRIDGE_OPS for node in shared_nodes
+        ):
+            self.report_reject(
+                ordered_nodes,
+                "Shared-qspec bridge cluster touches uint8 model IO.",
+            )
+            return
+
         if self._annotate_while_with_additional_inputs(root_node, adjacent_qspecs):
             return
 
@@ -734,20 +760,9 @@ def _annotate_shared_cluster(self, root_node: Node) -> None:
         return
 
     def annotate(self, model: torch.fx.GraphModule) -> None:  # type: ignore[override]
-        targets = self.targets
-        if self._model_has_uint8_io(model):
-            targets = [
-                target for target in targets if target not in self._UINT8_IO_BRIDGE_OPS
-            ]
-
-        original_targets = self.targets
-        self.targets = targets
-        try:
-            for node in model.graph.nodes:
-                if node.target in self.targets and not self._is_annotated(node):
-                    self._annotate_shared_cluster(node)
-        finally:
-            self.targets = original_targets
+        for node in model.graph.nodes:
+            if node.target in self.targets and not self._is_annotated(node):
+                self._annotate_shared_cluster(node)
 
     def validate(self, model: torch.fx.GraphModule) -> bool:  # type: ignore[override]
         return True

backends/arm/quantizer/quantization_config.py

@@ -356,7 +356,7 @@ def get_output_act_qspec(
 
         If node is a pooling or upsample operator, returns a shared quantization spec.
         If no weight spec is configured, return ``None``.
-        If node is a `to.dtype` operator, returns a fixed quantization spec if the input is integer and the output is float32.
+        If node is a `to.dtype` operator, returns a fixed quantization spec if the input is integer and the output is floating-point.
 
         """
 
@@ -391,7 +391,6 @@ def get_output_act_qspec(
                 isinstance(input_val, torch.Tensor)
                 and isinstance(output_val, torch.Tensor)
                 and CastCheck.is_integer_to_float(input_val.dtype, output_val.dtype)
-                and output_val.dtype == torch.float32
             ):
                 return FixedQParamsQuantizationSpec(
                     dtype=input_val.dtype,

backends/arm/test/misc/test_quant_custom_meta.py

@@ -105,6 +105,5 @@ def test_quantized_to_float_transition_tosa_INT_FP(fp_extension: bool):
         )
     pipeline.quantizer.set_module_type(torch.nn.Sigmoid, None)  # type: ignore
     pipeline.quantizer.set_module_type(torch.nn.Conv1d, None)  # type: ignore
-    pipeline.quantizer.set_io(None)  # type: ignore
 
     pipeline.run()