Quantization doc cleanups (#767)

Summary:
Pull Request resolved: #767

.

Reviewed By: kimishpatel, kirklandsign

Differential Revision: D50107717

fbshipit-source-id: 1e412c07c0c5a93e383136371a3fbbbee1e4aef1

Author: jerryzh168

docs/source/_static/img/executorch-entry-points.png

@@ -42,7 +42,7 @@ To lower edge ops to backend ops, a pass will perform pattern matching to identi
 * `transform()`. An API on ExportProgram that allows users to provide custom passes. Note that this is not guarded by any validator so the soundness of the program is not guaranteed.
 * [ExecutorchBackendConfig.passes](https://github.com/pytorch/executorch/blob/main/exir/capture/_config.py#L40). If added here, the pass will be part of the lowering process from backend dialect to ExecutorchProgram.
 
-Example: one such pass is QuantFusion. This pass takes a "canonical quantization pattern", ie. "dequant - some_op - quant" and fuses this pattern into a single operator that is backend specific, i.e. `quantized_decomposed::some_op`. You can find more details [here](./quantization-custom-quantization.md). Another simpler example is [here](https://github.com/pytorch/executorch/blob/main/exir/passes/replace_edge_with_backend_pass.py#L20) where we replace `sym_size` operators to the ones that are understood by ExecuTorch
+Example: one such pass is QuantFusion. This pass takes a "canonical quantization pattern", ie. "dequant - some_op - quant" and fuses this pattern into a single operator that is backend specific, i.e. `quantized_decomposed::some_op`. Another simpler example is [here](https://github.com/pytorch/executorch/blob/main/exir/passes/replace_edge_with_backend_pass.py#L20) where we replace `sym_size` operators to the ones that are understood by ExecuTorch
 
 
 ### Pattern Binding Decorator

docs/source/compiler-backend-dialect.md

@@ -153,7 +153,7 @@ Topics in this section will help you get started with ExecuTorch.
    :caption: Quantization
    :hidden:
 
-   quantization-custom-quantization
+   quantization-overview
 
 .. toctree::
    :glob:

docs/source/index.rst

@@ -109,10 +109,10 @@ Here we initialize the `XNNPACKQuantizer` and set the quantization config to be
 
 We can then configure the `XNNPACKQuantizer` as we wish. We set the following configs below as an example:
 ```python
-quantizer.set_global(qconfig_opt)  # qconfig_opt is an optional quantization config
-    .set_object_type(torch.nn.Conv2d, qconfig_opt) # can be a module type
-    .set_object_type(torch.nn.functional.linear, qconfig_opt) # or torch functional op
-    .set_module_name("foo.bar", qconfig_opt)
+quantizer.set_global(quantization_config)
+    .set_object_type(torch.nn.Conv2d, quantization_config) # can configure by module type
+    .set_object_type(torch.nn.functional.linear, quantization_config) # or torch functional op typea
+    .set_module_name("foo.bar", quantization_config)  # or by module fully qualified name
 ```
 
 ### Quantizing your model with the XNNPACKQuantizer

docs/source/native-delegates-executorch-xnnpack-delegate.md

@@ -0,0 +1,16 @@
+# Quantization Overview
+Quantization is a process that reduces the precision of computations and lowers memory footprint in the model. To learn more, please visit the [ExecuTorch concepts page](./concepts.md#quantization). This is particularly useful for edge devices, which typically have limited resources such as processing power, memory, and battery life. By using quantization, we can make our models more efficient and enable them to run effectively on these devices.
+
+In terms of flow, quantization happens early in the ExecuTorch stack:
+
+![ExecuTorch Entry Points](/_static/img/executorch-entry-points.png).
+
+A more detailed workflow can be found in the [ExecuTorch tutorial](./tutorials/export-to-executorch-tutorial).
+
+Quantization is usually tied to execution backends that have quantized operators implemented. Thus each backend is opinionated about how the model should be quantized, expressed in a backend specific ``Quantizer`` class. ``Quantizer`` provides API for modeling users in terms of how they want their model to be quantized and also passes on the user intention to quantization workflow.
+
+Backend developers will need to implement their own ``Quantizer`` to express how different operators or operator patterns are quantized in their backend. This is accomplished via [Annotation API](https://pytorch.org/tutorials/prototype/pt2e_quantizer.html) provided by quantization workflow. Since Quantizer is also user facing, it will expose specific APIs for modeling users to configure how they want the model to be quantized. Each backend should provide their own API documentation for their ``Quantizer``.
+
+Modeling user will use the ``Quantizer`` specific to their target backend to quantize their model, e.g. ``XNNPACKQuantizer``.
+
+For an example quantization flow with ``XNPACKQuantizer``, more docuemntations and tutorials, please see ``Performing Quantization`` section in [ExecuTorch tutorial](./tutorials/export-to-executorch-tutorial).

docs/source/quantization-custom-quantization.md

@@ -215,7 +215,7 @@ def f(x, y):
 #
 # Compared to
 # `FX Graph Mode Quantization <https://pytorch.org/tutorials/prototype/fx_graph_mode_ptq_static.html>`__,
-# we will need to call two new APIs: ``prepare_pt2e`` and ``compare_pt2e``
+# we will need to call two new APIs: ``prepare_pt2e`` and ``convert_pt2e``
 # instead of ``prepare_fx`` and ``convert_fx``. It differs in that
 # ``prepare_pt2e`` takes a backend-specific ``Quantizer`` as an argument, which
 # will annotate the nodes in the graph with information needed to quantize the
@@ -234,8 +234,10 @@ def f(x, y):
 
 quantizer = XNNPACKQuantizer().set_global(get_symmetric_quantization_config())
 prepared_graph = prepare_pt2e(pre_autograd_aten_dialect, quantizer)
+# calibrate with a sample dataset
 converted_graph = convert_pt2e(prepared_graph)
 print("Quantized Graph")
+print(converted_graph)
 
 aten_dialect: ExportedProgram = export(converted_graph, example_args)
 print("ATen Dialect Graph")
@@ -244,7 +246,7 @@ def f(x, y):
 ######################################################################
 # More information on how to quantize a model, and how a backend can implement a
 # ``Quantizer`` can be found
-# `here <https://pytorch.org/tutorials/prototype/pt2e_quant_ptq_static.html>`__ .
+# `here <https://pytorch.org/docs/main/quantization.html#prototype-pytorch-2-export-quantization>`__.
 
 ######################################################################
 # Lowering to Edge Dialect
@@ -634,7 +636,7 @@ def forward(self, x):
 # ^^^^^^^^^^^^^^^
 #
 # - `torch.export Documentation <https://pytorch.org/docs/2.1/export.html>`__
-# - `Quantization Tutorial <https://pytorch.org/tutorials/prototype/pt2e_quant_ptq_static.html>`__
+# - `Quantization Documentation <https://pytorch.org/docs/main/quantization.html#prototype-pytorch-2-export-quantization>`__
 # - `IR Spec <../ir-exir.html>`__
 # - `Writing Compiler Passes + Partitioner Documentation <../compiler-custom-compiler-passes.html>`__
 # - `Backend Delegation Documentation <../compiler-delegate-and-partitioner.html>`__