Merge branch 'main' of github.com:pytorch/tutorials into tutorial-audit-T228122175

Author: AlannaBurke

.ci/docker/requirements.txt

@@ -1,9 +1,10 @@
 # --extra-index-url https://download.pytorch.org/whl/cu117/index.html # Use this to run/publish tutorials against the latest binaries during the RC stage. Comment out after the release. Each release verify the correct cuda version.
 # Refer to ./jenkins/build.sh for tutorial build instructions
 
-sphinx==5.0.0
+sphinx==5.3.0
 sphinx-gallery==0.11.1
-sphinx_design
+sphinx-reredirects==0.1.4
+sphinx-design==0.4.0
 docutils==0.16
 sphinx-copybutton
 sphinx_sitemap==2.6.0

.jenkins/build.sh

@@ -151,6 +151,12 @@ elif [[ "${JOB_TYPE}" == "manager" ]]; then
   # Step 7: push new HTML files and static files to gh-pages
   if [[ "$COMMIT_SOURCE" == "refs/heads/master" || "$COMMIT_SOURCE" == "refs/heads/main" ]]; then
     git clone https://github.com/pytorch/tutorials.git -b gh-pages gh-pages
+    # Clean up directories that contain tutorials
+    
+    for dir in beginner intermediate prototype recipes advanced distributed vision text audio; do
+      rm -rf "gh-pages/$dir"
+    done
+    
     cp -r docs/* gh-pages/
     pushd gh-pages
     # DANGER! DO NOT REMOVE THE `set +x` SETTING HERE!

beginner_source/hyperparameter_tuning_tutorial.py

@@ -184,7 +184,7 @@ def forward(self, x):
 #         inputs, labels = inputs.to(device), labels.to(device)
 #
 # The code now supports training on CPUs, on a single GPU, and on multiple GPUs. Notably, Ray
-# also supports `fractional GPUs <https://docs.ray.io/en/master/using-ray-with-gpus.html#fractional-gpus>`_
+# also supports `fractional GPUs <https://docs.ray.io/en/latest/ray-core/scheduling/accelerators.html#fractional-accelerators>`_
 # so we can share GPUs among trials, as long as the model still fits on the GPU memory. We'll come back
 # to that later.
 #

beginner_source/saving_loading_models.py

@@ -227,43 +227,30 @@
 # normalization layers to evaluation mode before running inference.
 # Failing to do this will yield inconsistent inference results.
 #
-# Export/Load Model in TorchScript Format
-# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# Saving an Exported Program
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #
-# One common way to do inference with a trained model is to use
-# `TorchScript <https://pytorch.org/docs/stable/jit.html>`__, an intermediate
-# representation of a PyTorch model that can be run in Python as well as in a
-# high performance environment like C++. TorchScript is actually the recommended model format
-# for scaled inference and deployment.
+# If you are using ``torch.export``, you can save and load your ``ExportedProgram`` using the
+# ``torch.export.save()`` and ``torch.export.load()`` APIs. with the ``.pt2`` file extension:
 #
-# .. note::
-#    Using the TorchScript format, you will be able to load the exported model and
-#    run inference without defining the model class.
-#
-# **Export:**
-#
-# .. code:: python
-#
-#    model_scripted = torch.jit.script(model) # Export to TorchScript
-#    model_scripted.save('model_scripted.pt') # Save
-#
-# **Load:**
+# .. code-block:: python
+# 
+#    class SimpleModel(torch.nn.Module):
+#         def forward(self, x):
+#             return x + 10
 #
-# .. code:: python
+#    # Create a sample input
+#    sample_input = torch.randn(5)
+# 
+#    # Export the model
+#    exported_program = torch.export.export(SimpleModel(), sample_input)
 #
-#    model = torch.jit.load('model_scripted.pt')
-#    model.eval()
+#    # Save the exported program
+#    torch.export.save(exported_program, 'exported_program.pt2')
 #
-# Remember that you must call ``model.eval()`` to set dropout and batch
-# normalization layers to evaluation mode before running inference.
-# Failing to do this will yield inconsistent inference results.
+#    # Load the exported program
+#    saved_exported_program = torch.export.load('exported_program.pt2')
 #
-# For more information on TorchScript, feel free to visit the dedicated
-# `tutorials <https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html>`__.
-# You will get familiar with the tracing conversion and learn how to
-# run a TorchScript module in a `C++ environment <https://pytorch.org/tutorials/advanced/cpp_export.html>`__.
-
-
 
 ######################################################################
 # Saving & Loading a General Checkpoint for Inference and/or Resuming Training

conf.py

@@ -45,7 +45,7 @@
 import plotly.io as pio
 from pathlib import Path
 pio.renderers.default = 'sphinx_gallery'
-
+from redirects import redirects
 
 import sphinx_gallery.gen_rst
 import multiprocessing
@@ -121,7 +121,8 @@ def wrapper(*args, **kwargs):
     'sphinx_copybutton',
     'sphinx_gallery.gen_gallery',
     'sphinx_design',
-    'sphinx_sitemap'
+    'sphinx_sitemap',
+    'sphinx_reredirects'
 ]
 
 intersphinx_mapping = {

index.rst

@@ -612,20 +612,6 @@ Welcome to PyTorch Tutorials
    :link: advanced/static_quantization_tutorial.html
    :tags: Quantization
 
-.. customcarditem::
-   :header: Grokking PyTorch Intel CPU Performance from First Principles
-   :card_description: A case study on the TorchServe inference framework optimized with Intel® Extension for PyTorch.
-   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
-   :link: intermediate/torchserve_with_ipex
-   :tags: Model-Optimization,Production
-
-.. customcarditem::
-   :header: Grokking PyTorch Intel CPU Performance from First Principles (Part 2)
-   :card_description: A case study on the TorchServe inference framework optimized with Intel® Extension for PyTorch (Part 2).
-   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
-   :link: intermediate/torchserve_with_ipex_2
-   :tags: Model-Optimization,Production
-
 .. customcarditem::
    :header: Multi-Objective Neural Architecture Search with Ax
    :card_description: Learn how to use Ax to search over architectures find optimal tradeoffs between accuracy and latency.
@@ -1071,8 +1057,6 @@ Additional Resources
    intermediate/dynamic_quantization_bert_tutorial
    intermediate/quantized_transfer_learning_tutorial
    advanced/static_quantization_tutorial
-   intermediate/torchserve_with_ipex
-   intermediate/torchserve_with_ipex_2
    intermediate/nvfuser_intro_tutorial
    intermediate/ax_multiobjective_nas_tutorial
    intermediate/torch_compile_tutorial

intermediate_source/rpc_async_execution.rst

@@ -15,8 +15,7 @@ Prerequisites:
 This tutorial demonstrates how to build batch-processing RPC applications with
 the `@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
 decorator, which helps to speed up training by reducing the number of blocked
-RPC threads and consolidating CUDA operations on the callee. This shares the
-same idea as `Batch Inference with TorchServe <https://pytorch.org/serve/batch_inference_with_ts.html>`__.
+RPC threads and consolidating CUDA operations on the callee.
 
 .. note:: This tutorial requires PyTorch v1.6.0 or above.
 

prototype_source/pt2e_quant_xpu_inductor.rst

@@ -85,6 +85,7 @@ We will start by performing the necessary imports, capturing the FX Graph from t
         exported_model = export_for_training(
             model,
             example_inputs,
+            strict=True
         ).module()
 
 

recipes_source/bundled_inputs.rst

@@ -88,6 +88,9 @@ The aforementioned ``Mega-Cache`` is composed of individual components that can
 * ``InductorCache``: A bundle of ``FXGraphCache`` and ``Triton`` cache.
 * ``AOTAutogradCache``: A cache of joint graph artifacts.
 * ``PGO-cache``: A cache of dynamic shape decisions to reduce number of recompilations.
+* `AutotuningCache <https://github.com/pytorch/pytorch/blob/795a6a0affd349adfb4e3df298b604b74f27b44e/torch/_inductor/runtime/autotune_cache.py#L116>`__: 
+    * ``Inductor`` generates ``Triton`` kernels and benchmarks them to select the fastest kernels.
+    * ``torch.compile``'s built-in ``AutotuningCache`` caches these results.
 
 All these cache artifacts are written to ``TORCHINDUCTOR_CACHE_DIR`` which by default will look like ``/tmp/torchinductor_myusername``.