Update on "[ET-VK] Move files using the Vulkan API to vk_api/"

and move from namespace `api` to `vkapi`. This gave me a major headache in the number of places to update.

This stack orgnaizes ET-VK neatly into three abstraction levels, both by folder and by namespace:
1. `namespace vkcompute` and `graph/`: for operator computation implementation and scheduling.
2. `namespace vkcompute::api` and `graph/api/`: for tensor objects (and other objects wrapping our VulkanBuffer/VulkanImage).
3. `namespace vkcompute::vkapi` and `graph/api/vk_api/`: for direct users of Vulkan API

Additionally, we have
- `namespace vkcompute::utils` and `graph/api/utils/`: for utils used by both namespace `api` and `vkapi`

Differential Revision: [D59281539](https://our.internmc.facebook.com/intern/diff/D59281539/)

[ghstack-poisoned]

Author: Jorge Pineda

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,47 @@
+name: 🐛 Bug Report
+description: Create a report to help us reproduce and fix the bug
+
+body:
+- type: markdown
+  attributes:
+    value: >
+      #### Before submitting a bug, please make sure the issue hasn't been already addressed by searching through [the existing and past issues](https://github.com/pytorch/executorch/issues?q=is%3Aissue+sort%3Acreated-desc+).
+- type: textarea
+  attributes:
+    label: 🐛 Describe the bug
+    description: |
+      Please provide a clear and concise description of what the bug is.
+
+      If relevant, add a minimal example so that we can reproduce the error by running the code.
+
+      If the code is too long (hopefully, it isn't), feel free to put it in a public gist and link it in the issue: https://gist.github.com.
+
+      Please also paste or describe the results you observe instead of the expected results. If you observe an error, please paste the error message including the **full** traceback of the exception. It may be relevant to wrap error messages in ```` ```triple quotes blocks``` ````.
+    placeholder: |
+      A clear and concise description of what the bug is.
+
+      ```python
+      # Sample code to reproduce the problem
+      ```
+
+      ```
+      The error message you got, with the full traceback.
+      ```
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Versions
+    description: |
+      Please run the following and paste the output below.
+      ```sh
+      wget https://raw.githubusercontent.com/pytorch/pytorch/main/torch/utils/collect_env.py
+      # For security purposes, please check the contents of collect_env.py before running it.
+      python collect_env.py
+      ```
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: true

.github/ISSUE_TEMPLATE/documentation.yml

@@ -0,0 +1,20 @@
+name: 📚 Documentation
+description: Report an issue related to https://pytorch.org/executorch/stable/index.html
+
+body:
+- type: textarea
+  attributes:
+    label: 📚 The doc issue
+    description: >
+      A clear and concise description of what content in https://pytorch.org/executorch/stable/index.html is an issue.
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Suggest a potential alternative/fix
+    description: >
+      Tell us how we could improve the documentation in this regard.
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,30 @@
+name: 🚀 Feature request
+description: Submit a proposal/request for a new ExecuTorch feature
+
+body:
+- type: textarea
+  attributes:
+    label: 🚀 The feature, motivation and pitch
+    description: >
+      A clear and concise description of the feature proposal. Please outline the motivation for the proposal. Is your feature request related to a specific problem? e.g., *"I'm working on X and would like Y to be possible"*. If this is related to another GitHub issue, please link here too.
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Alternatives
+    description: >
+      A description of any alternative solutions or features you've considered, if any.
+- type: textarea
+  attributes:
+    label: Additional context
+    description: >
+      Add any other context or screenshots about the feature request.
+- type: textarea
+  attributes:
+    label: RFC (Optional)
+    description: >
+      Explain the design in enough detail.
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!

backends/arm/quantizer/arm_quantizer.py

@@ -41,7 +41,7 @@
 )
 from torch.ao.quantization.qconfig import _ObserverOrFakeQuantizeConstructor
 from torch.ao.quantization.quantizer import QuantizationSpec, Quantizer
-from torch.fx import Node
+from torch.fx import GraphModule, Node
 
 __all__ = [
     "ArmQuantizer",
@@ -172,33 +172,40 @@ def _get_supported_config_and_operators() -> List[OperatorConfig]:
     return _get_supported_symmetric_config_and_operators()
 
 
-def _get_module_name_filter(module_name: str):
+NodeFilterType = Callable[[Node], bool]
+"""Type for a Node Filter used by annotators. A Node filter is a function that takes
+    a Node and returns whether the node should be annotated or not.
+"""
+
+
+def _get_module_name_filter(module_name: str) -> NodeFilterType:
     """Get the module_name_filter function for a given module name, the filter accepts
     a node and checks if the node comes from a module that has certain module name
 
     For example:
         node: linear_op = call_function[...](...)  # comes from a module with name blocks.sub.linear1
 
-
     >> module_name_filter = _get_module_name_filter("blocks.sub")
     >> print(module_name_filter(node))
     True  # the node is from "blocks.sub" based on the fully qualified name "blocks.sub.linear1"
     """
 
+    name_start = len("L['self'].")
+
     def module_name_filter(n: Node) -> bool:
-        # example: {
+        # node_stack example: {
         #    'L__self___sub': ("L['self'].sub", <class '....Sub'>),
         #    'L__self___sub_linear': ("L['self'].sub.linear", <class 'torch.nn.modules.linear.Linear'>)
         # }
         # get_attr nodes doesn't have nn_module_stack?
         nn_module_stack = n.meta.get("nn_module_stack", {})
-        names = [n[len("L['self'].") :] for n, klass in nn_module_stack.values()]
+        names = [name[name_start:] for name, _ in nn_module_stack.values()]
         return module_name in names
 
     return module_name_filter
 
 
-def _get_module_type_filter(tp: Callable):
+def _get_module_type_filter(tp: Callable) -> NodeFilterType:
     """Get the module_type_filter function for a given module type, the filter accepts
     a node and checks if the node comes from a module that has certain module type
 
@@ -212,7 +219,7 @@ def _get_module_type_filter(tp: Callable):
     """
 
     def module_type_filter(n: Node) -> bool:
-        # example: {
+        # node_stack example: {
         #     'L__self___sub': ("L['self'].sub", <class '....Sub'>),
         #     'L__self___sub_linear': ("L['self'].sub.linear", <class 'torch.nn.modules.linear.Linear'>)
         # }
@@ -225,7 +232,7 @@ def module_type_filter(n: Node) -> bool:
 
 def _get_not_module_type_or_name_filter(
     tp_list: List[Callable], module_name_list: List[str]
-) -> Callable[[Node], bool]:
+) -> NodeFilterType:
     module_type_filters = [_get_module_type_filter(tp) for tp in tp_list]
     module_name_list_filters = [_get_module_name_filter(m) for m in module_name_list]
 
@@ -238,62 +245,32 @@ def not_module_type_or_name_filter(n: Node) -> bool:
 class ArmQuantizer(Quantizer):
     supported_config_and_operators = _get_supported_config_and_operators()
 
-    # A list of supported static quantization ops (both PTQ and QAT)
+    # A list of supported static quantization annotators, in order of application.
+    # For example, fusions come before singular ops.
     # The name must match the name used when registering the annotator.
-    # Preserve the order that fusions come before singular ops
-    STATIC_OPS = ["linear", "conv", "adaptive_avg_pool2d", "max_pool2d", "add", "mul"]
-
-    def __init__(self):
+    STATIC_ANNOTATION_ORDER = [
+        "linear",
+        "conv",
+        "adaptive_avg_pool2d",
+        "max_pool2d",
+        "add",
+        "mul",
+    ]
+
+    def __init__(self) -> None:
         super().__init__()
         self.global_config: Optional[QuantizationConfig] = None
-        self.operator_type_config: Dict[
-            torch._ops.OpOverloadPacket, Optional[QuantizationConfig]
-        ] = {}
         self.module_type_config: Dict[Callable, Optional[QuantizationConfig]] = {}
         self.module_name_config: Dict[str, Optional[QuantizationConfig]] = {}
 
-    @classmethod
-    def get_supported_quantization_configs(cls) -> List[QuantizationConfig]:
-        op_configs: Set[QuantizationConfig] = set({})
-        for spec, _ in cls.supported_config_and_operators:
-            op_configs.add(spec)
-        return list(op_configs)
-
-    @classmethod
-    def get_supported_operator_for_quantization_config(
-        cls, quantization_config: Optional[QuantizationConfig]
-    ) -> List[OperatorPatternType]:
-        if quantization_config is None:
-            all_ops = []
-            for _, ops in cls.supported_config_and_operators:
-                all_ops.extend(ops)
-            return all_ops
-
-        for config, ops in cls.supported_config_and_operators:
-            # note: this assumes each entry in cls.supported_spec_and_operators
-            # corresponds to one spec, e.g. we don't have
-            # [(spec1, op_list1), (spec1, op_list2), (spec2, op_list3)]
-            # where the first and second entry have the same spec but did not
-            # merge the op list
-            if config == quantization_config:
-                return ops
-        return []
-
     def set_global(self, quantization_config: QuantizationConfig) -> ArmQuantizer:
+        """Set quantization_config for submodules that are not already annotated by name or type filters."""
         self.global_config = quantization_config
         return self
 
-    def set_operator_type(
-        self,
-        operator_type: torch._ops.OpOverloadPacket,
-        quantization_config: QuantizationConfig,
-    ) -> ArmQuantizer:
-        self.operator_type_config[operator_type] = quantization_config
-        return self
-
     def set_module_type(
         self, module_type: Callable, quantization_config: QuantizationConfig
-    ):
+    ) -> ArmQuantizer:
         """Set quantization_config for a submodule with type: `module_type`, for example:
         quantizer.set_module_name(Sub) or quantizer.set_module_name(nn.Linear), it will quantize all supported operator/operator
         patterns in the submodule with this module type with the given `quantization_config`
@@ -303,7 +280,7 @@ def set_module_type(
 
     def set_module_name(
         self, module_name: str, quantization_config: Optional[QuantizationConfig]
-    ):
+    ) -> ArmQuantizer:
         """Set quantization_config for a submodule with name: `module_name`, for example:
         quantizer.set_module_name("blocks.sub"), it will quantize all supported operator/operator
         patterns in the submodule with this module name with the given `quantization_config`
@@ -314,15 +291,13 @@ def set_module_name(
         self.module_name_config[module_name] = quantization_config
         return self
 
-    def transform_for_annotation(
-        self, model: torch.fx.GraphModule
-    ) -> torch.fx.GraphModule:
+    def transform_for_annotation(self, model: GraphModule) -> GraphModule:
         """An initial pass for transforming the graph to prepare it for annotation.
         Currently transforms scalar values to tensor attributes.
         """
         return convert_scalars_to_attrs(model)
 
-    def annotate(self, model: torch.fx.GraphModule) -> torch.fx.GraphModule:
+    def annotate(self, model: GraphModule) -> GraphModule:
         """Performs the quantization annotation on the graph.
             Currently only does static quantization annotation.
         Args:
@@ -336,10 +311,10 @@ def annotate(self, model: torch.fx.GraphModule) -> torch.fx.GraphModule:
 
     def _annotate_all_static_patterns(
         self,
-        model: torch.fx.GraphModule,
+        model: GraphModule,
         quantization_config: Optional[QuantizationConfig],
         filter_fn: Optional[Callable[[Node], bool]] = None,
-    ) -> torch.fx.GraphModule:
+    ) -> GraphModule:
         """Loops over all STATIC_OPS and runs the corresponding registred annotator.
         Args:
             model: The model to annotate statically.
@@ -353,13 +328,13 @@ def _annotate_all_static_patterns(
         if quantization_config is None:
             return model
 
-        for op in self.STATIC_OPS:
+        for op in self.STATIC_ANNOTATION_ORDER:
             OP_TO_ANNOTATOR[op](model, quantization_config, filter_fn)
         return model
 
     def _annotate_for_static_quantization_config(
-        self, model: torch.fx.GraphModule
-    ) -> torch.fx.GraphModule:
+        self, model: GraphModule
+    ) -> GraphModule:
         """Matches the correct QuantizationConfig with the correct module using a filter
         when running _annotate_all_static_patterns.
         """
@@ -382,9 +357,36 @@ def _annotate_for_static_quantization_config(
         )
         return model
 
-    def validate(self, model: torch.fx.GraphModule) -> None:
+    def validate(self, model: GraphModule) -> None:
         pass
 
     @classmethod
     def get_supported_operators(cls) -> List[OperatorConfig]:
         return cls.supported_config_and_operators
+
+    @classmethod
+    def get_supported_quantization_configs(cls) -> List[QuantizationConfig]:
+        op_configs: Set[QuantizationConfig] = set({})
+        for spec, _ in cls.supported_config_and_operators:
+            op_configs.add(spec)
+        return list(op_configs)
+
+    @classmethod
+    def get_supported_operator_for_quantization_config(
+        cls, quantization_config: Optional[QuantizationConfig]
+    ) -> List[OperatorPatternType]:
+        if quantization_config is None:
+            all_ops = []
+            for _, ops in cls.supported_config_and_operators:
+                all_ops.extend(ops)
+            return all_ops
+
+        for config, ops in cls.supported_config_and_operators:
+            # note: this assumes each entry in cls.supported_spec_and_operators
+            # corresponds to one spec, e.g. we don't have
+            # [(spec1, op_list1), (spec1, op_list2), (spec2, op_list3)]
+            # where the first and second entry have the same spec but did not
+            # merge the op list
+            if config == quantization_config:
+                return ops
+        return []