Remove cpu doc (#3923)

Author: ZhaoqiongZ

docs/images/performancev2.1.10/four_card.png

@@ -27,7 +27,7 @@ Intel® Extension for PyTorch* has been released as an open–source project at
 You can find more information about the product at:
 
 - `Features <https://intel.github.io/intel-extension-for-pytorch/gpu/latest/tutorials/features>`_
-- `Performance <https://intel.github.io/intel-extension-for-pytorch/cpu/latest/tutorials/performance>`_ 
+- `Performance <./tutorials/performance.html>`_ 
 
 Architecture
 ------------
@@ -59,6 +59,7 @@ The team tracks bugs and enhancement requests using `GitHub issues <https://gith
    tutorials/introduction
    tutorials/features
    Large Language Models (LLM)<tutorials/llm>
+   tutorials/performance
    tutorials/technical_details
    tutorials/releases
    tutorials/performance_tuning/known_issues
@@ -82,15 +83,6 @@ The team tracks bugs and enhancement requests using `GitHub issues <https://gith
 
    tutorials/api_doc
 
-.. toctree::
-   :maxdepth: 3
-   :caption: PERFORMANCE TUNING
-   :hidden:
-
-   tutorials/performance_tuning/tuning_guide
-   tutorials/performance_tuning/launch_script
-   tutorials/performance_tuning/torchserve   
-   
 .. toctree::
    :maxdepth: 3
    :caption: CONTRIBUTING GUIDE

docs/images/performancev2.1.10/single_card.png

@@ -105,39 +105,3 @@ C++ API
 
 .. doxygenfunction:: xpu::get_queue_from_stream
 
-
-CPU-Specific
-************
-
-Miscellaneous
-=============
-
-.. currentmodule:: intel_extension_for_pytorch
-.. autofunction:: enable_onednn_fusion
-
-Quantization (Prototype)
-============
-
-.. automodule:: intel_extension_for_pytorch.quantization
-.. autofunction:: prepare
-.. autofunction:: convert
-
-Introduction is avaiable at `feature page <./features/int8_recipe_tuning_api.md>`_.
-
-.. autofunction:: autotune
-
-CPU Runtime
-===========
-
-.. automodule:: intel_extension_for_pytorch.cpu.runtime
-.. autofunction:: is_runtime_ext_enabled
-.. autoclass:: CPUPool
-.. autoclass:: pin
-.. autoclass:: MultiStreamModuleHint
-.. autoclass:: MultiStreamModule
-.. autoclass:: Task
-.. autofunction:: get_core_list_of_node_id
-
-.. .. automodule:: intel_extension_for_pytorch.quantization
-..    :members:
-

docs/images/performancev2.1.10/single_tile.png

@@ -29,26 +29,22 @@ Intel® Extension for PyTorch* automatically converts a model to channels last m
 Auto Mixed Precision (AMP)
 --------------------------
 
-Benefiting from less memory usage and computation, low precision data types typically speed up both training and inference workloads. Furthermore, accelerated by Intel® native hardware instructions, including Intel® Deep Learning Boost (Intel® DL Boost) on the 3rd Generation Xeon® Scalable Processors (aka Cooper Lake), as well as the Intel® Advanced Matrix Extensions (Intel® AMX) instruction set on the 4th next generation of Intel® Xeon® Scalable Processors (aka Sapphire Rapids), low precision data type, bfloat 16 and float16, provide further boosted performance. We recommend to use AMP for accelerating convolutional and matmul based neural networks.
+Benefiting from less memory usage and computation, low precision data types typically speed up both training and inference workloads. 
+On GPU side, support of BFloat16 and Float16 are both available in Intel® Extension for PyTorch\*. BFloat16 is the default low precision floating data type when AMP is enabled.
 
-The support of Auto Mixed Precision (AMP) with `BFloat16 on CPU <https://www.intel.com/content/www/us/en/developer/articles/technical/intel-deep-learning-boost-new-instruction-bfloat16.html>`_ and BFloat16 optimization of operators has been enabled in Intel® Extension for PyTorch\*, and partially upstreamed to PyTorch master branch. These optimizations will be landed in PyTorch master through PRs that are being submitted and reviewed. On GPU side, support of BFloat16 and Float16 are both available in Intel® Extension for PyTorch\*. BFloat16 is the default low precision floating data type when AMP is enabled.
-
-Detailed information of AMP for GPU and CPU are available at `Auto Mixed Precision (AMP) on GPU <features/amp_gpu.md>`_ and `Auto Mixed Precision (AMP) on CPU <features/amp_cpu.md>`_ respectively.
+Detailed information of AMP for GPU are available at `Auto Mixed Precision (AMP) on GPU <features/amp_gpu.md>`_.
 
 .. toctree::
    :hidden:
    :maxdepth: 1
 
-   features/amp_cpu
    features/amp_gpu
 
 
 Quantization
 ------------
 
-Intel® Extension for PyTorch* provides built-in INT8 quantization recipes to deliver good statistical accuracy for most popular DL workloads including CNN, NLP and recommendation models on CPU side. On top of that, if users would like to tune for a higher accuracy than what the default recipe provides, a recipe tuning API powered by Intel® Neural Compressor is provided for users to try.
-
-Check more detailed information for `INT8 Quantization [CPU] <features/int8_overview.md>`_ and `INT8 recipe tuning API guide (Prototype, *NEW feature in 1.13.0* on CPU) <features/int8_recipe_tuning_api.md>`_ on CPU side.
+Intel® Extension for PyTorch* currently supports imperative mode and TorchScript mode for post-training static quantization on GPU. This section illustrates the quantization workflow on Intel GPUs.
 
 Check more detailed information for `INT8 Quantization [XPU] <features/int8_overview_xpu.md>`_. 
 
@@ -58,8 +54,6 @@ On Intel® GPUs, Intel® Extension for PyTorch* also provides INT4 and FP8 Quant
    :hidden:
    :maxdepth: 1
 
-   features/int8_overview
-   features/int8_recipe_tuning_api
    features/int8_overview_xpu
    features/int4
    features/float8
@@ -68,7 +62,7 @@ On Intel® GPUs, Intel® Extension for PyTorch* also provides INT4 and FP8 Quant
 Distributed Training
 --------------------
 
-To meet demands of large scale model training over multiple devices, distributed training on Intel® GPUs and CPUs are supported. Two alternative methodologies are available. Users can choose either to use PyTorch native distributed training module, `Distributed Data Parallel (DDP) <https://pytorch.org/docs/stable/notes/ddp.html>`_, with `Intel® oneAPI Collective Communications Library (oneCCL) <https://www.intel.com/content/www/us/en/developer/tools/oneapi/oneccl.html>`_ support via `Intel® oneCCL Bindings for PyTorch (formerly known as torch_ccl) <https://github.com/intel/torch-ccl>`_ or use Horovod with `Intel® oneAPI Collective Communications Library (oneCCL) <https://www.intel.com/content/www/us/en/developer/tools/oneapi/oneccl.html>`_ support (Prototype).
+To meet demands of large scale model training over multiple devices, distributed training on Intel® GPUs is supported. Two alternative methodologies are available. Users can choose either to use PyTorch native distributed training module, `Distributed Data Parallel (DDP) <https://pytorch.org/docs/stable/notes/ddp.html>`_, with `Intel® oneAPI Collective Communications Library (oneCCL) <https://www.intel.com/content/www/us/en/developer/tools/oneapi/oneccl.html>`_ support via `Intel® oneCCL Bindings for PyTorch (formerly known as torch_ccl) <https://github.com/intel/torch-ccl>`_ or use Horovod with `Intel® oneAPI Collective Communications Library (oneCCL) <https://www.intel.com/content/www/us/en/developer/tools/oneapi/oneccl.html>`_ support (Prototype).
 
 For more detailed information, check `DDP <features/DDP.md>`_ and `Horovod (Prototype) <features/horovod.md>`_.
 
@@ -202,81 +196,4 @@ For more detailed information, check `Compute Engine <features/compute_engine.md
 
    features/compute_engine
 
-CPU-Specific
-************
-
-Operator Optimization
----------------------
-
-Intel® Extension for PyTorch* also optimizes operators and implements several customized operators for performance boosts. A few ATen operators are replaced by their optimized counterparts in Intel® Extension for PyTorch* via the ATen registration mechanism. Some customized operators are implemented for several popular topologies. For instance, ROIAlign and NMS are defined in Mask R-CNN. To improve performance of these topologies, Intel® Extension for PyTorch* also optimized these customized operators.
-
-.. currentmodule:: intel_extension_for_pytorch.nn
-.. autoclass:: FrozenBatchNorm2d
-
-.. currentmodule:: intel_extension_for_pytorch.nn.functional
-.. autofunction:: interaction
-
-**Auto kernel selection** is a feature that enables users to tune for better performance with GEMM operations. It is provided as parameter –auto_kernel_selection, with boolean value, of the ipex.optimize() function. By default, the GEMM kernel is computed with oneMKL primitives. However, under certain circumstances oneDNN primitives run faster. Users are able to set –auto_kernel_selection to True to run GEMM kernels with oneDNN primitives.” -> "We aim to provide good default performance by leveraging the best of math libraries and enabled weights_prepack, and it has been verified with broad set of models. If you would like to try other alternatives, you can use auto_kernel_selection toggle in ipex.optimize to switch, and you can disable weights_preack in ipex.optimize if you are concerning the memory footprint more than performance gain. However in majority cases, keeping default is what we recommend.
-
-
-Runtime Extension
------------------
-
-Intel® Extension for PyTorch* Runtime Extension provides PyTorch frontend APIs for users to get finer-grained control of the thread runtime and provides:
-
-- Multi-stream inference via the Python frontend module MultiStreamModule.
-- Spawn asynchronous tasks from both Python and C++ frontend.
-- Program core bindings for OpenMP threads from both Python and C++ frontend.
-
-.. note:: Intel® Extension for PyTorch* Runtime extension is still in the prototype stage. The API is subject to change. More detailed descriptions are available in the `API Documentation <api_doc.html>`_.
-
-For more detailed information, check `Runtime Extension <features/runtime_extension.md>`_.
-
-.. toctree::
-   :hidden:
-   :maxdepth: 1
-
-   features/runtime_extension
-
-
-Codeless Optimization (Prototype, *NEW feature in 1.13.\**)
---------------------------------------------------------------
-
-This feature enables users to get performance benefits from Intel® Extension for PyTorch* without changing Python scripts. It hopefully eases the usage and has been verified working well with broad scope of models, though in few cases there could be small overhead comparing to applying optimizations with Intel® Extension for PyTorch* APIs.
-
-For more detailed information, check `Codeless Optimization <features/codeless_optimization.md>`_.
-
-.. toctree::
-   :hidden:
-   :maxdepth: 1
-
-   features/codeless_optimization.md
-
-
-Graph Capture (Prototype, *NEW feature in 1.13.0\**)
--------------------------------------------------------
-
-Since graph mode is key for deployment performance, this feature automatically captures graphs based on set of technologies that PyTorch supports, such as TorchScript and TorchDynamo. Users won't need to learn and try different PyTorch APIs to capture graphs, instead, they can turn on a new boolean flag `--graph_mode` (default off) in `ipex.optimize` to get the best of graph optimization.
-
-For more detailed information, check `Graph Capture <features/graph_capture.md>`_.
-
-.. toctree::
-   :hidden:
-   :maxdepth: 1
-
-   features/graph_capture
-
-
-HyperTune (Prototype, *NEW feature in 1.13.0\**)
----------------------------------------------------
-
-HyperTune is an prototype feature to perform hyperparameter/execution configuration searching. The searching is used in various areas such as optimization of hyperparameters of deep learning models. The searching is extremely useful in real situations when the number of hyperparameters, including configuration of script execution, and their search spaces are huge that manually tuning these hyperparameters/configuration is impractical and time consuming. Hypertune automates this process of execution configuration searching for the `launcher <performance_tuning/launch_script.md>`_ and Intel® Extension for PyTorch*.
-
-For more detailed information, check `HyperTune <features/hypertune.md>`_.
-
-.. toctree::
-   :hidden:
-   :maxdepth: 1
-
-   features/hypertune