diff --git a/.ci/docker/requirements.txt b/.ci/docker/requirements.txt
index 01e6a82926..6babb63e78 100644
--- a/.ci/docker/requirements.txt
+++ b/.ci/docker/requirements.txt
@@ -14,9 +14,8 @@ tqdm==4.66.1
 numpy==1.24.4
 matplotlib
 librosa
-torch==2.4
+torch==2.5
 torchvision
-torchtext
 torchdata
 networkx
 PyHamcrest
@@ -70,5 +69,5 @@ pycocotools
 semilearn==0.3.2
 torchao==0.5.0
 segment_anything==1.0
-torchrec==0.8.0
-fbgemm-gpu==0.8.0
+torchrec==1.0.0; platform_system == "Linux"
+fbgemm-gpu==1.0.0; platform_system == "Linux"
diff --git a/.github/workflows/StalePRs.yml b/.github/workflows/StalePRs.yml
index 4a8ddd6865..4fbfc78550 100644
--- a/.github/workflows/StalePRs.yml
+++ b/.github/workflows/StalePRs.yml
@@ -57,11 +57,11 @@ jobs:
             const STALE_CLOSE_THRESHOLD_MS = 1000 * 60 * 60 * 24 * 30;
 
             const STALE_MESSAGE =
-              "Looks like this PR hasn't been updated in a while so we're going to go ahead and mark this as `Stale`. <br>" +
-              "Feel free to remove the `Stale` label if you feel this was a mistake. <br>" +
-              "If you are unable to remove the `Stale` label please contact a maintainer in order to do so. <br>" +
+              "Looks like this PR hasn't been updated in a while so we're going to go ahead and mark this as `stale`. <br>" +
+              "Feel free to remove the `stale` label if you feel this was a mistake. <br>" +
+              "If you are unable to remove the `stale` label please contact a maintainer in order to do so. <br>" +
               "If you want the bot to never mark this PR stale again, add the `no-stale` label.<br>" +
-              "`Stale` pull requests will automatically be closed after 30 days of inactivity.<br>";
+              "`stale` pull requests will automatically be closed after 30 days of inactivity.<br>";
 
             let numAPIRequests = 0;
             let numProcessed = 0;
@@ -79,7 +79,7 @@ jobs:
 
               // Check if the PR is stale, according to our configured thresholds.
               let staleThresholdMillis;
-              if (labels.includes("Stale")) {
+              if (labels.includes("stale")) {
                 core.info(`[${pull.number}] PR is labeled stale, checking whether we should close it.`);
                 staleThresholdMillis = STALE_CLOSE_THRESHOLD_MS;
               } else {
@@ -97,7 +97,7 @@ jobs:
 
               // At this point, we know we should do something.
               // For PRs already labeled stale, close them.
-              if (labels.includes("Stale")) {
+              if (labels.includes("stale")) {
                 core.info(`[${pull.number}] Closing PR.`);
                 numAPIRequests += 1;
                 await github.rest.issues.update({
@@ -123,7 +123,7 @@ jobs:
                   owner: "pytorch",
                   repo: "tutorials",
                   issue_number: pull.number,
-                  labels: ["Stale"],
+                  labels: ["stale"],
                 });
               }
             }
diff --git a/.github/workflows/link_checkPR.yml b/.github/workflows/link_checkPR.yml
new file mode 100644
index 0000000000..1fde237159
--- /dev/null
+++ b/.github/workflows/link_checkPR.yml
@@ -0,0 +1,52 @@
+#Checks links in a PR to ensure they are valid. If link is valid but failing, it can be added to the .lycheeignore file
+#Use the skip-link-check label on a PR to skip checking links on a PR
+
+name: link check on PR
+
+on:
+  pull_request:
+    branches: [main]
+
+jobs:
+  linkChecker:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Get Changed Files
+        id: changed-files
+        uses: tj-actions/changed-files@v41
+
+      - name: Check for Skip Label
+        id: skip-label
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const labels = await github.rest.issues.listLabelsOnIssue({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number
+            });
+            return labels.data.some(label => label.name === 'skip-link-check');
+          
+      - name: Check Links
+        if: steps.skip-label.outputs.result == 'false'
+        uses: lycheeverse/lychee-action@v1
+        with:
+          args: --accept=200,403,429 --base . --verbose --no-progress ${{ steps.changed-files.outputs.all_changed_files }}
+          token: ${{ secrets.CUSTOM_TOKEN }}
+          fail: true
+          
+      - name: Skip Message
+        if: steps.skip-label.outputs.result == 'true'
+        run: echo "Link check was skipped due to the presence of the 'skip-link-check' label."
+        
+      - name: Suggestions
+        if: failure()
+        run: |
+          echo -e "\nPlease review the links reported in the Check links step above."
+          echo -e "If a link is valid but fails due to a CAPTCHA challenge, IP blocking, login requirements, etc., consider adding such links to .lycheeignore file to bypass future checks.\n"
+          exit 1
diff --git a/.jenkins/build.sh b/.jenkins/build.sh
index 60867ce1d3..e6ecaf6712 100755
--- a/.jenkins/build.sh
+++ b/.jenkins/build.sh
@@ -22,9 +22,8 @@ sudo apt-get install -y pandoc
 #Install PyTorch Nightly for test.
 # Nightly - pip install --pre torch torchvision torchaudio -f https://download.pytorch.org/whl/nightly/cu102/torch_nightly.html
 # Install 2.5 to merge all 2.4 PRs - uncomment to install nightly binaries (update the version as needed).
-pip uninstall -y torch torchvision torchaudio torchtext torchdata
-pip3 install torch==2.5.0 torchvision torchaudio --no-cache-dir --index-url https://download.pytorch.org/whl/test/cu124
-pip3 install fbgemm-gpu==1.0.0 torchrec==1.0.0 --no-cache-dir --index-url https://download.pytorch.org/whl/test/cu124
+# pip uninstall -y torch torchvision torchaudio torchtext torchdata
+# pip3 install torch==2.5.0 torchvision torchaudio --no-cache-dir --index-url https://download.pytorch.org/whl/test/cu124
 
 # Install two language tokenizers for Translation with TorchText tutorial
 python -m spacy download en_core_web_sm
diff --git a/.jenkins/validate_tutorials_built.py b/.jenkins/validate_tutorials_built.py
index b11f5fdd94..2aaa5d6ef7 100644
--- a/.jenkins/validate_tutorials_built.py
+++ b/.jenkins/validate_tutorials_built.py
@@ -10,8 +10,8 @@
 
 NOT_RUN = [
     "beginner_source/basics/intro",  # no code
+    "beginner_source/introyt/introyt_index", # no code
     "beginner_source/onnx/intro_onnx",
-    "beginner_source/translation_transformer",
     "beginner_source/profiler",
     "beginner_source/saving_loading_models",
     "beginner_source/introyt/captumyt",
@@ -22,9 +22,6 @@
     "beginner_source/former_torchies/tensor_tutorial_old",
     "beginner_source/examples_autograd/polynomial_autograd",
     "beginner_source/examples_autograd/polynomial_custom_function",
-    "beginner_source/torchtext_custom_dataset_tutorial", # not building with 2.3 RC, might be able to turn on with GA
-    "beginner_source/text_sentiment_ngrams_tutorial", # not building with 2.3 RC, might be able to turn on with GA
-    "beginner_source/t5_tutorial", # re-enable after this is fixed: https://github.com/pytorch/text/issues/1756
     "intermediate_source/mnist_train_nas",  # used by ax_multiobjective_nas_tutorial.py
     "intermediate_source/fx_conv_bn_fuser",
     "intermediate_source/_torch_export_nightly_tutorial",  # does not work on release
diff --git a/.lycheeignore b/.lycheeignore
new file mode 100644
index 0000000000..4894b6d72f
--- /dev/null
+++ b/.lycheeignore
@@ -0,0 +1,11 @@
+# Used for links to be ignored during the link check.
+# Add link to file along with comment as to why it should be ignored
+
+#Example link in some of the tutorials that should be ignored
+file:///f:/libtmp/some_file
+
+#Ignore links with "file:///" to catch any other example links
+file:\/\/\/.*
+
+# Ignore colab link in the setting of conf.py
+https://pytorch.org/tutorials/beginner/colab/n
diff --git a/Makefile b/Makefile
index 0a36670dd6..19c6d59768 100644
--- a/Makefile
+++ b/Makefile
@@ -82,10 +82,6 @@ download:
 	wget -nv -N http://dl.fbaipublicfiles.com/pythia/data/vocab.tar.gz -P $(DATADIR)
 	tar $(TAROPTS) -xzf $(DATADIR)/vocab.tar.gz -C ./beginner_source/data/
 
-	# Download dataset for beginner_source/torchtext_custom_dataset_tutorial.py
-	wget -nv -N https://www.manythings.org/anki/deu-eng.zip -P $(DATADIR)
-	unzip -o $(DATADIR)/deu-eng.zip -d beginner_source/data/
-
 	# Download PennFudanPed dataset for intermediate_source/torchvision_tutorial.py
 	wget https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip -P $(DATADIR)
 	unzip -o $(DATADIR)/PennFudanPed.zip -d intermediate_source/data/
diff --git a/_static/css/custom2.css b/_static/css/custom2.css
index 4e263b6775..a4ec9396ee 100644
--- a/_static/css/custom2.css
+++ b/_static/css/custom2.css
@@ -17,3 +17,21 @@
     margin-bottom: 5px;
   }
 }
+
+/* Left nav for 2nd level nav */
+
+.pytorch-left-menu li.toctree-l2 {
+  padding-left: 10px;
+}
+
+.pytorch-left-menu li.toctree-l2.current > a, {
+   color: #ee4c2c;
+}
+
+.pytorch-left-menu li.toctree-l2.current a:link.reference.internal {
+   color: #ee4c2c;
+}
+
+.pytorch-left-menu li.toctree-l1.current > a:before {
+   content: "";
+}
diff --git a/_static/img/compiled_autograd/call_hook_node.png b/_static/img/compiled_autograd/call_hook_node.png
new file mode 100644
index 0000000000..3e094cf6f7
Binary files /dev/null and b/_static/img/compiled_autograd/call_hook_node.png differ
diff --git a/_static/img/compiled_autograd/entire_verbose_log.png b/_static/img/compiled_autograd/entire_verbose_log.png
new file mode 100644
index 0000000000..4ce2b8538e
Binary files /dev/null and b/_static/img/compiled_autograd/entire_verbose_log.png differ
diff --git a/_static/img/compiled_autograd/recompile_due_to_dynamic.png b/_static/img/compiled_autograd/recompile_due_to_dynamic.png
new file mode 100644
index 0000000000..41ae56acf2
Binary files /dev/null and b/_static/img/compiled_autograd/recompile_due_to_dynamic.png differ
diff --git a/_static/img/compiled_autograd/recompile_due_to_node.png b/_static/img/compiled_autograd/recompile_due_to_node.png
new file mode 100644
index 0000000000..800a178458
Binary files /dev/null and b/_static/img/compiled_autograd/recompile_due_to_node.png differ
diff --git a/_static/img/itt_tutorial/vtune_xpu_config.png b/_static/img/itt_tutorial/vtune_xpu_config.png
new file mode 100644
index 0000000000..80dd1812d2
Binary files /dev/null and b/_static/img/itt_tutorial/vtune_xpu_config.png differ
diff --git a/_static/img/itt_tutorial/vtune_xpu_timeline.png b/_static/img/itt_tutorial/vtune_xpu_timeline.png
new file mode 100644
index 0000000000..43818cf105
Binary files /dev/null and b/_static/img/itt_tutorial/vtune_xpu_timeline.png differ
diff --git a/_static/img/trace_xpu_img.png b/_static/img/trace_xpu_img.png
new file mode 100644
index 0000000000..2eca0a78cb
Binary files /dev/null and b/_static/img/trace_xpu_img.png differ
diff --git a/_static/js/custom.js b/_static/js/custom.js
new file mode 100644
index 0000000000..3e6c7fb831
--- /dev/null
+++ b/_static/js/custom.js
@@ -0,0 +1,52 @@
+document.addEventListener("DOMContentLoaded", function() {
+  // Select all <li> elements with the class "toctree-l1"
+  var toctreeItems = document.querySelectorAll('li.toctree-l1');
+
+  toctreeItems.forEach(function(item) {
+    // Find the link within the item
+    var link = item.querySelector('a');
+    var nestedList = item.querySelector('ul');
+
+    if (link && nestedList) {
+      // Create a span element for the "[+]" or "[-]" sign
+      var expandSign = document.createElement('span');
+      expandSign.style.cursor = 'pointer'; // Make it look clickable
+
+      // Use the link text as a unique key for localStorage
+      var sectionKey = 'section_' + link.textContent.trim().replace(/\s+/g, '_');
+
+      // Retrieve the saved state from localStorage
+      var isExpanded = localStorage.getItem(sectionKey);
+
+      // If no state is saved, default to expanded for "Learn the Basics" and collapsed for others
+      if (isExpanded === null) {
+        isExpanded = (link.textContent.trim() === 'Learn the Basics') ? 'true' : 'false';
+        localStorage.setItem(sectionKey, isExpanded);
+      }
+
+      if (isExpanded === 'true') {
+        nestedList.style.display = 'block'; // Expand the section
+        expandSign.textContent = '[-] '; // Show "[-]" since it's expanded
+      } else {
+        nestedList.style.display = 'none'; // Collapse the section
+        expandSign.textContent = '[+] '; // Show "[+]" since it's collapsed
+      }
+
+      // Add a click event to toggle the nested list
+      expandSign.addEventListener('click', function() {
+        if (nestedList.style.display === 'none') {
+          nestedList.style.display = 'block';
+          expandSign.textContent = '[-] '; // Change to "[-]" when expanded
+          localStorage.setItem(sectionKey, 'true'); // Save state
+        } else {
+          nestedList.style.display = 'none';
+          expandSign.textContent = '[+] '; // Change back to "[+]" when collapsed
+          localStorage.setItem(sectionKey, 'false'); // Save state
+        }
+      });
+
+      // Insert the sign before the link
+      link.parentNode.insertBefore(expandSign, link);
+    }
+  });
+});
diff --git a/_templates/layout.html b/_templates/layout.html
index 1c632de63f..fc120ef502 100644
--- a/_templates/layout.html
+++ b/_templates/layout.html
@@ -1,5 +1,23 @@
 {% extends "!layout.html" %}
 
+
+<!-- Overrides needed for the multilevel nav -->
+{% block menu %}
+    {% if 'singlehtml' not in builder %}
+        {% set global_toc = toctree(collapse=theme_collapse_navigation|tobool,
+                                    includehidden=theme_includehidden|tobool,
+                                    titles_only=True) %}
+    {% endif %}
+    {% if global_toc %}
+        {{ global_toc }}
+    {% else %}
+        <!-- Local TOC -->
+        <div class="local-toc">{{ toc }}</div>
+    {% endif %}
+{% endblock %}
+ <!-- End of overrides needed for the multilevel nav -->
+
+
 {%- block content %}
 {{ super() }}
 <script>
@@ -29,6 +47,7 @@
     </div>
 {% endblock %}
 
+
 {% block footer %}
 {{ super() }}
 <script>
diff --git a/advanced_source/cpp_export.rst b/advanced_source/cpp_export.rst
index 45556a5320..3cf58b592e 100644
--- a/advanced_source/cpp_export.rst
+++ b/advanced_source/cpp_export.rst
@@ -1,6 +1,8 @@
 Loading a TorchScript Model in C++
 =====================================
 
+.. note:: TorchScript is no longer in active development.
+
 As its name suggests, the primary interface to PyTorch is the Python
 programming language. While Python is a suitable and preferred language for
 many scenarios requiring dynamism and ease of iteration, there are equally many
diff --git a/advanced_source/ddp_pipeline.rst b/advanced_source/ddp_pipeline.rst
new file mode 100644
index 0000000000..bf9e4d28f3
--- /dev/null
+++ b/advanced_source/ddp_pipeline.rst
@@ -0,0 +1,10 @@
+Training Transformer models using Distributed Data Parallel and Pipeline Parallelism
+====================================================================================
+
+This tutorial has been deprecated.
+
+Redirecting to the latest parallelism APIs in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/dist_overview.html#parallelism-apis'" />
diff --git a/advanced_source/torch-script-parallelism.rst b/advanced_source/torch-script-parallelism.rst
index 5a2fd86e1f..e775aacca5 100644
--- a/advanced_source/torch-script-parallelism.rst
+++ b/advanced_source/torch-script-parallelism.rst
@@ -1,6 +1,8 @@
 Dynamic Parallelism in TorchScript
 ==================================
 
+.. note:: TorchScript is no longer in active development.
+
 In this tutorial, we introduce the syntax for doing *dynamic inter-op parallelism*
 in TorchScript. This parallelism has the following properties:
 
diff --git a/advanced_source/torch_script_custom_classes.rst b/advanced_source/torch_script_custom_classes.rst
index cccb86ff4c..6638e7b0d8 100644
--- a/advanced_source/torch_script_custom_classes.rst
+++ b/advanced_source/torch_script_custom_classes.rst
@@ -1,6 +1,8 @@
 Extending TorchScript with Custom C++ Classes
 ===============================================
 
+.. note:: TorchScript is no longer in active development.
+
 This tutorial is a follow-on to the
 :doc:`custom operator <torch_script_custom_ops>`
 tutorial, and introduces the API we've built for binding C++ classes into TorchScript
diff --git a/beginner_source/Intro_to_TorchScript_tutorial.py b/beginner_source/Intro_to_TorchScript_tutorial.py
index 21ee32ff38..458cf65463 100644
--- a/beginner_source/Intro_to_TorchScript_tutorial.py
+++ b/beginner_source/Intro_to_TorchScript_tutorial.py
@@ -4,6 +4,8 @@
 
 **Authors:** James Reed (jamesreed@fb.com), Michael Suo (suo@fb.com), rev2
 
+.. note:: TorchScript is no longer in active development.
+
 This tutorial is an introduction to TorchScript, an intermediate
 representation of a PyTorch model (subclass of ``nn.Module``) that
 can then be run in a high-performance environment such as C++.
diff --git a/beginner_source/README.txt b/beginner_source/README.txt
index 5017c80b86..14f3b3047e 100644
--- a/beginner_source/README.txt
+++ b/beginner_source/README.txt
@@ -20,7 +20,3 @@ Beginner Tutorials
 5. nlp/* and deep_learning_nlp_tutorial.rst
 	Deep Learning for NLP with Pytorch
 	https://pytorch.org/tutorials/beginner/deep_learning_nlp_tutorial.html
-
-6. transformer_translation.py
-	Language Translation with Transformers
-	https://pytorch.org/tutorials/beginner/translation_transformer.html
diff --git a/beginner_source/basics/intro.py b/beginner_source/basics/intro.py
index bc0d3d72a2..6c048dcaec 100644
--- a/beginner_source/basics/intro.py
+++ b/beginner_source/basics/intro.py
@@ -13,9 +13,9 @@
 ===================
 
 Authors:
-`Suraj Subramanian <https://github.com/suraj813>`_,
+`Suraj Subramanian <https://github.com/subramen>`_,
 `Seth Juarez <https://github.com/sethjuarez/>`_,
-`Cassie Breviu <https://github.com/cassieview/>`_,
+`Cassie Breviu <https://github.com/cassiebreviu/>`_,
 `Dmitry Soshnikov <https://soshnikov.com/>`_,
 `Ari Bornstein <https://github.com/aribornstein/>`_
 
@@ -49,6 +49,16 @@
 .. include:: /beginner_source/basics/qs_toc.txt
 
 .. toctree::
+   :maxdepth: 2
    :hidden:
 
+   quickstart_tutorial
+   tensorqs_tutorial
+   data_tutorial
+   transforms_tutorial
+   buildmodel_tutorial
+   autogradqs_tutorial
+   optimization_tutorial
+   saveloadrun_tutorial
+
 """
diff --git a/beginner_source/bettertransformer_tutorial.rst b/beginner_source/bettertransformer_tutorial.rst
index 60ffa52ea8..76aebd839a 100644
--- a/beginner_source/bettertransformer_tutorial.rst
+++ b/beginner_source/bettertransformer_tutorial.rst
@@ -1,251 +1,10 @@
 Fast Transformer Inference with Better Transformer
-===============================================================
+==================================================
 
-**Author**: `Michael Gschwind <https://github.com/mikekgfb>`__
+This tutorial has been deprecated.
 
-This tutorial introduces Better Transformer (BT) as part of the PyTorch 1.12 release. 
-In this tutorial, we show how to use Better Transformer for production 
-inference with torchtext.  Better Transformer is a production ready fastpath to
-accelerate deployment of Transformer models with high performance on CPU and GPU.
-The fastpath feature works transparently for models based either directly on 
-PyTorch core ``nn.module`` or with torchtext.  
-
-Models which can be accelerated by Better Transformer fastpath execution are those
-using the following PyTorch core ``torch.nn.module`` classes ``TransformerEncoder``, 
-``TransformerEncoderLayer``, and ``MultiHeadAttention``.  In addition, torchtext has 
-been updated to use the core library modules to benefit from fastpath acceleration.
-(Additional modules may be enabled with fastpath execution in the future.)
-
-Better Transformer offers two types of acceleration:
-
-* Native multihead attention (MHA) implementation for CPU and GPU to improve overall execution efficiency.  
-* Exploiting sparsity in NLP inference.  Because of variable input lengths, input
-  tokens may contain a large number of padding tokens for which processing may be
-  skipped, delivering significant speedups.
-
-Fastpath execution is subject to some criteria. Most importantly, the model 
-must be executed in inference mode and operate on input tensors that do not collect 
-gradient tape information (e.g., running with torch.no_grad). 
-
-To follow this example in Google Colab, `click here 
-<https://colab.research.google.com/drive/1KZnMJYhYkOMYtNIX5S3AGIYnjyG0AojN?usp=sharing>`__.
-
-Better Transformer Features in This Tutorial
---------------------------------------------
-
-* Load pretrained models (created before PyTorch version 1.12 without Better Transformer)
-* Run and benchmark inference on CPU with and without BT fastpath (native MHA only)
-* Run and benchmark inference on (configurable) DEVICE with and without BT fastpath (native MHA only)
-* Enable sparsity support
-* Run and benchmark inference on (configurable) DEVICE with and without BT fastpath (native MHA + sparsity)
-
-Additional Information
------------------------
-Additional information about Better Transformer may be found in the PyTorch.Org blog  
-`A Better Transformer for Fast Transformer Inference
-<https://pytorch.org/blog/a-better-transformer-for-fast-transformer-encoder-inference//>`__.
-
-
-
-1. Setup
-
-1.1 Load pretrained models
-
-We download the XLM-R model from the predefined torchtext models by following the instructions in
-`torchtext.models <https://pytorch.org/text/main/models.html>`__.  We also set the DEVICE to execute 
-on-accelerator tests.  (Enable GPU execution for your environment as appropriate.)
-
-.. code-block:: python 
-
-    import torch
-    import torch.nn as nn
-
-    print(f"torch version: {torch.__version__}")
-
-    DEVICE = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
-
-    print(f"torch cuda available: {torch.cuda.is_available()}")
-
-    import torch, torchtext
-    from torchtext.models import RobertaClassificationHead
-    from torchtext.functional import to_tensor
-    xlmr_large = torchtext.models.XLMR_LARGE_ENCODER
-    classifier_head = torchtext.models.RobertaClassificationHead(num_classes=2, input_dim = 1024)
-    model = xlmr_large.get_model(head=classifier_head)
-    transform = xlmr_large.transform()
-
-1.2 Dataset Setup
-
-We set up two types of inputs: a small input batch and a big input batch with sparsity.
-
-.. code-block:: python
-
-    small_input_batch = [
-                   "Hello world", 
-                   "How are you!"
-    ]
-    big_input_batch = [
-                   "Hello world", 
-                   "How are you!", 
-                   """`Well, Prince, so Genoa and Lucca are now just family estates of the
-    Buonapartes. But I warn you, if you don't tell me that this means war,
-    if you still try to defend the infamies and horrors perpetrated by
-    that Antichrist- I really believe he is Antichrist- I will have
-    nothing more to do with you and you are no longer my friend, no longer
-    my 'faithful slave,' as you call yourself! But how do you do? I see
-    I have frightened you- sit down and tell me all the news.`
-
-    It was in July, 1805, and the speaker was the well-known Anna
-    Pavlovna Scherer, maid of honor and favorite of the Empress Marya
-    Fedorovna. With these words she greeted Prince Vasili Kuragin, a man
-    of high rank and importance, who was the first to arrive at her
-    reception. Anna Pavlovna had had a cough for some days. She was, as
-    she said, suffering from la grippe; grippe being then a new word in
-    St. Petersburg, used only by the elite."""
-    ]
-
-Next, we select either the small or large input batch, preprocess the inputs and test the model. 
-
-.. code-block:: python
-
-    input_batch=big_input_batch
-
-    model_input = to_tensor(transform(input_batch), padding_value=1)
-    output = model(model_input)
-    output.shape
-
-Finally, we set the benchmark iteration count:
-
-.. code-block:: python
-
-    ITERATIONS=10
-
-2. Execution
-
-2.1  Run and benchmark inference on CPU with and without BT fastpath (native MHA only)
-
-We run the model on CPU, and collect profile information:  
-
-* The first run uses traditional ("slow path") execution.
-* The second run enables BT fastpath execution by putting the model in inference mode using `model.eval()` and disables gradient collection with `torch.no_grad()`.
-
-You can see an improvement (whose magnitude will depend on the CPU model) when the model is executing on CPU.  Notice that the fastpath profile shows most of the execution time
-in the native `TransformerEncoderLayer` implementation `aten::_transformer_encoder_layer_fwd`.
-
-.. code-block:: python
-
-    print("slow path:")
-    print("==========")
-    with torch.autograd.profiler.profile(use_cuda=False) as prof:
-      for i in range(ITERATIONS):  
-        output = model(model_input)
-    print(prof)
-
-    model.eval()
-
-    print("fast path:")
-    print("==========")
-    with torch.autograd.profiler.profile(use_cuda=False) as prof:
-      with torch.no_grad():
-        for i in range(ITERATIONS):
-          output = model(model_input)
-    print(prof)
-
-
-2.2  Run and benchmark inference on (configurable) DEVICE with and without BT fastpath (native MHA only)
-
-We check the BT sparsity setting:
-
-.. code-block:: python
-
-    model.encoder.transformer.layers.enable_nested_tensor
-    
-
-We disable the BT sparsity:
-
-.. code-block:: python
-
-    model.encoder.transformer.layers.enable_nested_tensor=False    
-    
- 
-We run the model on DEVICE, and collect profile information for native MHA execution on DEVICE:  
-
-* The first run uses traditional ("slow path") execution.
-* The second run enables BT fastpath execution by putting the model in inference mode using `model.eval()`
-  and disables gradient collection with `torch.no_grad()`.
-
-When executing on a GPU, you should see a significant speedup, in particular for the small input batch setting:
-
-.. code-block:: python
-
-    model.to(DEVICE)
-    model_input = model_input.to(DEVICE)
-
-    print("slow path:")
-    print("==========")
-    with torch.autograd.profiler.profile(use_cuda=True) as prof:
-      for i in range(ITERATIONS):  
-        output = model(model_input)
-    print(prof)
-
-    model.eval()
-
-    print("fast path:")
-    print("==========")
-    with torch.autograd.profiler.profile(use_cuda=True) as prof:
-      with torch.no_grad():
-        for i in range(ITERATIONS):
-          output = model(model_input)
-    print(prof)
-    
-
-2.3 Run and benchmark inference on (configurable) DEVICE with and without BT fastpath (native MHA + sparsity)
-
-We enable sparsity support:
-
-.. code-block:: python
-
-    model.encoder.transformer.layers.enable_nested_tensor = True
-
-We run the model on DEVICE, and collect profile information for native MHA and sparsity support execution on DEVICE:  
-
-* The first run uses traditional ("slow path") execution.
-* The second run enables BT fastpath execution by putting the model in inference mode using `model.eval()` and disables gradient collection with `torch.no_grad()`.
-
-When executing on a GPU, you should see a significant speedup, in particular for the large input batch setting which includes sparsity:
-
-.. code-block:: python
-
-    model.to(DEVICE)
-    model_input = model_input.to(DEVICE)
-
-    print("slow path:")
-    print("==========")
-    with torch.autograd.profiler.profile(use_cuda=True) as prof:
-      for i in range(ITERATIONS):  
-        output = model(model_input)
-    print(prof)
-
-    model.eval()
-
-    print("fast path:")
-    print("==========")
-    with torch.autograd.profiler.profile(use_cuda=True) as prof:
-      with torch.no_grad():
-        for i in range(ITERATIONS):
-          output = model(model_input)
-    print(prof)
-
-
-Summary
--------
-
-In this tutorial, we have introduced fast transformer inference with 
-Better Transformer fastpath execution in torchtext using PyTorch core 
-Better Transformer support for Transformer Encoder models.  We have 
-demonstrated the use of Better Transformer with models trained prior to 
-the availability of BT fastpath execution.  We have demonstrated and 
-benchmarked the use of both BT fastpath execution modes, native MHA execution
-and BT sparsity acceleration. 
+Redirecting in 3 seconds...
 
+.. raw:: html
 
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/'" />
diff --git a/beginner_source/ddp_series_multigpu.rst b/beginner_source/ddp_series_multigpu.rst
index f8335ba8cf..ef6549d4de 100644
--- a/beginner_source/ddp_series_multigpu.rst
+++ b/beginner_source/ddp_series_multigpu.rst
@@ -9,7 +9,7 @@
 Multi GPU training with DDP
 ===========================
 
-Authors: `Suraj Subramanian <https://github.com/suraj813>`__
+Authors: `Suraj Subramanian <https://github.com/subramen>`__
 
 .. grid:: 2
 
@@ -19,13 +19,13 @@ Authors: `Suraj Subramanian <https://github.com/suraj813>`__
       -  How to migrate a single-GPU training script to multi-GPU via DDP
       -  Setting up the distributed process group
       -  Saving and loading models in a distributed setup
-      
+
       .. grid:: 1
 
          .. grid-item::
 
             :octicon:`code-square;1.0em;` View the code used in this tutorial on `GitHub <https://github.com/pytorch/examples/blob/main/distributed/ddp-tutorial-series/multigpu.py>`__
-      
+
    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
       :class-card: card-prerequisites
 
@@ -45,11 +45,11 @@ In the `previous tutorial <ddp_series_theory.html>`__, we got a high-level overv
 In this tutorial, we start with a single-GPU training script and migrate that to running it on 4 GPUs on a single node.
 Along the way, we will talk through important concepts in distributed training while implementing them in our code.
 
-.. note:: 
+.. note::
    If your model contains any ``BatchNorm`` layers, it needs to be converted to ``SyncBatchNorm`` to sync the running stats of ``BatchNorm``
    layers across replicas.
 
-   Use the helper function 
+   Use the helper function
    `torch.nn.SyncBatchNorm.convert_sync_batchnorm(model) <https://pytorch.org/docs/stable/generated/torch.nn.SyncBatchNorm.html#torch.nn.SyncBatchNorm.convert_sync_batchnorm>`__ to convert all ``BatchNorm`` layers in the model to ``SyncBatchNorm``.
 
 
@@ -58,27 +58,27 @@ Diff for `single_gpu.py <https://github.com/pytorch/examples/blob/main/distribut
 These are the changes you typically make to a single-GPU training script to enable DDP.
 
 Imports
-~~~~~~~
+-------
 -  ``torch.multiprocessing`` is a PyTorch wrapper around Python's native
    multiprocessing
 -  The distributed process group contains all the processes that can
    communicate and synchronize with each other.
 
-.. code-block:: diff
+.. code-block:: python
 
-    import torch
-    import torch.nn.functional as F
-    from utils import MyTrainDataset
+   import torch
+   import torch.nn.functional as F
+   from utils import MyTrainDataset
 
-    + import torch.multiprocessing as mp
-    + from torch.utils.data.distributed import DistributedSampler
-    + from torch.nn.parallel import DistributedDataParallel as DDP
-    + from torch.distributed import init_process_group, destroy_process_group
-    + import os
+   import torch.multiprocessing as mp
+   from torch.utils.data.distributed import DistributedSampler
+   from torch.nn.parallel import DistributedDataParallel as DDP
+   from torch.distributed import init_process_group, destroy_process_group
+   import os
 
 
 Constructing the process group
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------
 
 -  First, before initializing the group process, call `set_device <https://pytorch.org/docs/stable/generated/torch.cuda.set_device.html?highlight=set_device#torch.cuda.set_device>`__,
    which sets the default GPU for each process. This is important to prevent hangs or excessive memory utilization on `GPU:0`
@@ -90,66 +90,66 @@ Constructing the process group
 -  Read more about `choosing a DDP
    backend <https://pytorch.org/docs/stable/distributed.html#which-backend-to-use>`__
 
-.. code-block:: diff
+.. code-block:: python
 
-    + def ddp_setup(rank: int, world_size: int):
-    +   """
-    +   Args:
-    +       rank: Unique identifier of each process
-    +      world_size: Total number of processes
-    +   """
-    +   os.environ["MASTER_ADDR"] = "localhost"
-    +   os.environ["MASTER_PORT"] = "12355"
-    +   torch.cuda.set_device(rank)
-    +   init_process_group(backend="nccl", rank=rank, world_size=world_size)
+   def ddp_setup(rank: int, world_size: int):
+      """
+      Args:
+          rank: Unique identifier of each process
+         world_size: Total number of processes
+      """
+      os.environ["MASTER_ADDR"] = "localhost"
+      os.environ["MASTER_PORT"] = "12355"
+      torch.cuda.set_device(rank)
+      init_process_group(backend="nccl", rank=rank, world_size=world_size)
 
 
 
 Constructing the DDP model
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
 
-.. code-block:: diff
+.. code-block:: python
 
-    - self.model = model.to(gpu_id)
-    + self.model = DDP(model, device_ids=[gpu_id])
+   self.model = DDP(model, device_ids=[gpu_id])
 
 Distributing input data
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
 
 -  `DistributedSampler <https://pytorch.org/docs/stable/data.html?highlight=distributedsampler#torch.utils.data.distributed.DistributedSampler>`__
    chunks the input data across all distributed processes.
+- The `DataLoader <https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader>`__ combines a dataset and a
+   sampler, and provides an iterable over the given dataset.
 -  Each process will receive an input batch of 32 samples; the effective
    batch size is ``32 * nprocs``, or 128 when using 4 GPUs.
 
-.. code-block:: diff
+.. code-block:: python
 
     train_data = torch.utils.data.DataLoader(
         dataset=train_dataset,
         batch_size=32,
-    -   shuffle=True,
-    +   shuffle=False,
-    +   sampler=DistributedSampler(train_dataset),
+        shuffle=False,  # We don't shuffle
+        sampler=DistributedSampler(train_dataset), # Use the Distributed Sampler here.
     )
 
--  Calling the ``set_epoch()`` method on the ``DistributedSampler`` at the beginning of each epoch is necessary to make shuffling work 
+-  Calling the ``set_epoch()`` method on the ``DistributedSampler`` at the beginning of each epoch is necessary to make shuffling work
    properly across multiple epochs. Otherwise, the same ordering will be used in each epoch.
 
-.. code-block:: diff
+.. code-block:: python
 
     def _run_epoch(self, epoch):
         b_sz = len(next(iter(self.train_data))[0])
-    +   self.train_data.sampler.set_epoch(epoch)
+        self.train_data.sampler.set_epoch(epoch)   # call this additional line at every epoch
         for source, targets in self.train_data:
           ...
           self._run_batch(source, targets)
 
 
 Saving model checkpoints
-~~~~~~~~~~~~~~~~~~~~~~~~
--  We only need to save model checkpoints from one process. Without this 
+------------------------
+-  We only need to save model checkpoints from one process. Without this
    condition, each process would save its copy of the identical mode. Read
    more on saving and loading models with
-   DDP `here <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html#save-and-load-checkpoints>`__  
+   DDP `here <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html#save-and-load-checkpoints>`__
 
 .. code-block:: diff
 
@@ -164,18 +164,18 @@ Saving model checkpoints
 .. warning::
    `Collective calls <https://pytorch.org/docs/stable/distributed.html#collective-functions>`__ are functions that run on all the distributed processes,
    and they are used to gather certain states or values to a specific process. Collective calls require all ranks to run the collective code.
-   In this example, `_save_checkpoint` should not have any collective calls because it is only run on the ``rank:0`` process. 
+   In this example, `_save_checkpoint` should not have any collective calls because it is only run on the ``rank:0`` process.
    If you need to make any collective calls, it should be before the ``if self.gpu_id == 0`` check.
 
 
 Running the distributed training job
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------
 
 -  Include new arguments ``rank`` (replacing ``device``) and
    ``world_size``.
 -  ``rank`` is auto-allocated by DDP when calling
    `mp.spawn <https://pytorch.org/docs/stable/multiprocessing.html#spawning-subprocesses>`__.
--  ``world_size`` is the number of processes across the training job. For GPU training, 
+-  ``world_size`` is the number of processes across the training job. For GPU training,
    this corresponds to the number of GPUs in use, and each process works on a dedicated GPU.
 
 .. code-block:: diff
@@ -189,7 +189,7 @@ Running the distributed training job
    +  trainer = Trainer(model, train_data, optimizer, rank, save_every)
       trainer.train(total_epochs)
    +  destroy_process_group()
-    
+
    if __name__ == "__main__":
       import sys
       total_epochs = int(sys.argv[1])
@@ -199,6 +199,24 @@ Running the distributed training job
    +  world_size = torch.cuda.device_count()
    +  mp.spawn(main, args=(world_size, total_epochs, save_every,), nprocs=world_size)
 
+Here's what the code looks like:
+
+.. code-block:: python
+   def main(rank, world_size, total_epochs, save_every):
+      ddp_setup(rank, world_size)
+      dataset, model, optimizer = load_train_objs()
+      train_data = prepare_dataloader(dataset, batch_size=32)
+      trainer = Trainer(model, train_data, optimizer, rank, save_every)
+      trainer.train(total_epochs)
+      destroy_process_group()
+
+   if __name__ == "__main__":
+      import sys
+      total_epochs = int(sys.argv[1])
+      save_every = int(sys.argv[2])
+      world_size = torch.cuda.device_count()
+      mp.spawn(main, args=(world_size, total_epochs, save_every,), nprocs=world_size)
+
 
 
 Further Reading
@@ -206,6 +224,6 @@ Further Reading
 
 -  `Fault Tolerant distributed training <ddp_series_fault_tolerance.html>`__  (next tutorial in this series)
 -  `Intro to DDP <ddp_series_theory.html>`__ (previous tutorial in this series)
--  `Getting Started with DDP <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html>`__ 
+-  `Getting Started with DDP <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html>`__
 -  `Process Group
-   initialization <https://pytorch.org/docs/stable/distributed.html#tcp-initialization>`__
+   Initialization <https://pytorch.org/docs/stable/distributed.html#tcp-initialization>`__
diff --git a/beginner_source/deeplabv3_on_android.rst b/beginner_source/deeplabv3_on_android.rst
index 5ca7f01ad0..7ec8347737 100644
--- a/beginner_source/deeplabv3_on_android.rst
+++ b/beginner_source/deeplabv3_on_android.rst
@@ -1,234 +1,10 @@
 Image Segmentation DeepLabV3 on Android
 =================================================
 
-**Author**: `Jeff Tang <https://github.com/jeffxtang>`_
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-**Reviewed by**: `Jeremiah Chung <https://github.com/jeremiahschung>`_
+Redirecting in 3 seconds...
 
-.. warning::
-    PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://pytorch.org/executorch-overview>`_, PyTorch’s all-new on-device inference library. You can also review our `end-to-end workflows <https://github.com/pytorch/executorch/tree/main/examples/portable#readme>`_ and review the `source code for DeepLabV3 <https://github.com/pytorch/executorch/tree/main/examples/models/deeplab_v3>`_.
+.. raw:: html
 
-
-Introduction
-------------
-
-Semantic image segmentation is a computer vision task that uses semantic labels to mark specific regions of an input image. The PyTorch semantic image segmentation `DeepLabV3 model <https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101>`_ can be used to label image regions with `20 semantic classes <http://host.robots.ox.ac.uk:8080/pascal/VOC/voc2007/segexamples/index.html>`_ including, for example, bicycle, bus, car, dog, and person. Image segmentation models can be very useful in applications such as autonomous driving and scene understanding.
-
-In this tutorial, we will provide a step-by-step guide on how to prepare and run the PyTorch DeepLabV3 model on Android, taking you from the beginning of having a model you may want to use on Android to the end of having a complete Android app using the model. We will also cover practical and general tips on how to check if your next favorable pretrained PyTorch models can run on Android, and how to avoid pitfalls.
-
-.. note:: Before going through this tutorial, you should check out `PyTorch Mobile for Android <https://pytorch.org/mobile/android/>`_ and give the PyTorch Android `Hello World <https://github.com/pytorch/android-demo-app/tree/master/HelloWorldApp>`_ example app a quick try. This tutorial will go beyond the image classification model, usually the first kind of model deployed on mobile. The complete code for this tutorial is available `here <https://github.com/pytorch/android-demo-app/tree/master/ImageSegmentation>`_.
-
-Learning Objectives
--------------------
-
-In this tutorial, you will learn how to:
-
-1. Convert the DeepLabV3 model for Android deployment.
-
-2. Get the output of the model for the example input image in Python and compare it to the output from the Android app.
-
-3. Build a new Android app or reuse an Android example app to load the converted model.
-
-4. Prepare the input into the format that the model expects and process the model output.
-
-5. Complete the UI, refactor, build and run the app to see image segmentation in action.
-
-Prerequisites
----------------
-
-* PyTorch 1.6 or 1.7
-
-* torchvision 0.7 or 0.8
-
-* Android Studio 3.5.1 or above with NDK installed
-
-Steps
----------
-
-1. Convert the DeepLabV3 model for Android deployment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The first step to deploying a model on Android is to convert the model into the `TorchScript <https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html>`_ format.
-
-.. note::
-    Not all PyTorch models can be converted to TorchScript at this time because a model definition may use language features that are not in TorchScript, which is a subset of Python. See the `Script and Optimize Recipe <../recipes/script_optimized.html>`_ for more details.
-
-Simply run the script below to generate the scripted model `deeplabv3_scripted.pt`:
-
-::
-
-    import torch
-
-    # use deeplabv3_resnet50 instead of resnet101 to reduce the model size
-    model = torch.hub.load('pytorch/vision:v0.7.0', 'deeplabv3_resnet50', pretrained=True)
-    model.eval()
-
-    scriptedm = torch.jit.script(model)
-    torch.jit.save(scriptedm, "deeplabv3_scripted.pt")
-
-The size of the generated `deeplabv3_scripted.pt` model file should be around 168MB. Ideally, a model should also be quantized for significant size reduction and faster inference before being deployed on an Android app. To have a general understanding of quantization, see the `Quantization Recipe <../recipes/quantization.html>`_ and the resource links there. We will cover in detail how to correctly apply a quantization workflow called Post Training `Static Quantization <https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html>`_ to the DeepLabV3 model in a future tutorial or recipe.
-
-2. Get example input and output of the model in Python
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Now that we have a scripted PyTorch model, let's test with some example inputs to make sure the model works correctly on Android. First, let's write a Python script that uses the model to make inferences and examine inputs and outputs. For this example of the DeepLabV3 model, we can reuse the code in Step 1 and in the `DeepLabV3 model hub site <https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101>`_. Add the following code snippet to the code above:
-
-::
-
-    from PIL import Image
-    from torchvision import transforms
-    input_image = Image.open("deeplab.jpg")
-    preprocess = transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-    ])
-
-    input_tensor = preprocess(input_image)
-    input_batch = input_tensor.unsqueeze(0)
-    with torch.no_grad():
-        output = model(input_batch)['out'][0]
-
-    print(input_batch.shape)
-    print(output.shape)
-
-Download `deeplab.jpg` from `here <https://github.com/jeffxtang/android-demo-app/blob/new_demo_apps/ImageSegmentation/app/src/main/assets/deeplab.jpg>`_, then run the script above and you will see the shapes of the input and output of the model:
-
-::
-
-    torch.Size([1, 3, 400, 400])
-    torch.Size([21, 400, 400])
-
-So if you provide the same image input `deeplab.jpg` of size 400x400 to the model on Android, the output of the model should have the size [21, 400, 400]. You should also print out at least the beginning parts of the actual data of the input and output, to be used in Step 4 below to compare with the actual input and output of the model when running in the Android app.
-
-3. Build a new Android app or reuse an example app and load the model
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-First, follow Step 3 of the `Model Preparation for Android recipe <../recipes/model_preparation_android.html#add-the-model-and-pytorch-library-on-android>`_ to use our model in an Android Studio project with PyTorch Mobile enabled. Because both DeepLabV3 used in this tutorial and MobileNet v2 used in the PyTorch Hello World Android example are computer vision models, you can also get the `Hello World example repo <https://github.com/pytorch/android-demo-app/tree/master/HelloWorldApp>`_ to make it easier to modify the code that loads the model and processes the input and output. The main goal in this step and Step 4 is to make sure the model `deeplabv3_scripted.pt` generated in Step 1 can indeed work correctly on Android.
-
-Now let's add `deeplabv3_scripted.pt` and `deeplab.jpg` used in Step 2 to the Android Studio project and modify the `onCreate` method in the `MainActivity` to resemble:
-
-.. code-block:: java
-
-    Module module = null;
-    try {
-      module = Module.load(assetFilePath(this, "deeplabv3_scripted.pt"));
-    } catch (IOException e) {
-      Log.e("ImageSegmentation", "Error loading model!", e);
-      finish();
-    }
-
-Then set a breakpoint at the line `finish()` and build and run the app. If the app doesn't stop at the breakpoint, it means  that the scripted model in Step 1 has been successfully loaded on Android.
-
-4. Process the model input and output for model inference
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-After the model loads in the previous step, let's verify that it works with expected inputs and can generate expected outputs. As the model input for the DeepLabV3 model is an image the same as that of the MobileNet v2 in the Hello World example, we will reuse some of the code in the `MainActivity.java <https://github.com/pytorch/android-demo-app/blob/master/HelloWorldApp/app/src/main/java/org/pytorch/helloworld/MainActivity.java>`_ file from Hello World for input processing. Replace the code snippet between `line 50 <https://github.com/pytorch/android-demo-app/blob/master/HelloWorldApp/app/src/main/java/org/pytorch/helloworld/MainActivity.java#L50>`_ and 73 in `MainActivity.java` with the following code:
-
-.. code-block:: java
-
-    final Tensor inputTensor = TensorImageUtils.bitmapToFloat32Tensor(bitmap,
-            TensorImageUtils.TORCHVISION_NORM_MEAN_RGB,
-            TensorImageUtils.TORCHVISION_NORM_STD_RGB);
-    final float[] inputs = inputTensor.getDataAsFloatArray();
-
-    Map<String, IValue> outTensors =
-        module.forward(IValue.from(inputTensor)).toDictStringKey();
-
-    // the key "out" of the output tensor contains the semantic masks
-    // see https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101
-    final Tensor outputTensor = outTensors.get("out").toTensor();
-    final float[] outputs = outputTensor.getDataAsFloatArray();
-
-    int width = bitmap.getWidth();
-    int height = bitmap.getHeight();
-
-.. note::
-    The model output is a dictionary for the DeepLabV3 model so we use `toDictStringKey` to correctly extract the result. For other models, the model output may also be a single tensor or a tuple of tensors, among other things.
-
-With the code changes shown above, you can set breakpoints after `final float[] inputs` and `final float[] outputs`, which populate the input tensor and output tensor data to float arrays for easy debugging. Run the app and when it stops at the breakpoints, compare the numbers in `inputs` and `outputs` with the model input and output data you see in Step 2 to see if they match. For the same inputs to the models running on Android and Python, you should get the same outputs.
-
-.. warning::
-    You may see different model outputs with the same image input when running on an Android emulator due to some Android emulator's floating point implementation issue. So it is best to test the app on a real Android device.
-
-All we have done so far is to confirm that the model of our interest can be scripted and run correctly in our Android app as in Python. The steps we walked through so far for using a model in an iOS app consumes the bulk, if not most, of our app development time, similar to how data preprocessing is the heaviest lift for a typical machine learning project.
-
-5. Complete the UI, refactor, build and run the app
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Now we are ready to complete the app and the UI to actually see the processed result as a new image. The output processing code should be like this, added to the end of the code snippet in Step 4:
-
-.. code-block:: java
-
-    int[] intValues = new int[width * height];
-    // go through each element in the output of size [WIDTH, HEIGHT] and
-    // set different color for different classnum
-    for (int j = 0; j < width; j++) {
-        for (int k = 0; k < height; k++) {
-            // maxi: the index of the 21 CLASSNUM with the max probability
-            int maxi = 0, maxj = 0, maxk = 0;
-            double maxnum = -100000.0;
-            for (int i=0; i < CLASSNUM; i++) {
-                if (outputs[i*(width*height) + j*width + k] > maxnum) {
-                    maxnum = outputs[i*(width*height) + j*width + k];
-                    maxi = i; maxj = j; maxk= k;
-                }
-            }
-            // color coding for person (red), dog (green), sheep (blue)
-            // black color for background and other classes
-            if (maxi == PERSON)
-                intValues[maxj*width + maxk] = 0xFFFF0000; // red
-            else if (maxi == DOG)
-                intValues[maxj*width + maxk] = 0xFF00FF00; // green
-            else if (maxi == SHEEP)
-                intValues[maxj*width + maxk] = 0xFF0000FF; // blue
-            else
-                intValues[maxj*width + maxk] = 0xFF000000; // black
-        }
-    }
-
-The constants used in the code above are defined in the beginning of the class `MainActivity`:
-
-.. code-block:: java
-
-    private static final int CLASSNUM = 21;
-    private static final int DOG = 12;
-    private static final int PERSON = 15;
-    private static final int SHEEP = 17;
-
-
-The implementation here is based on the understanding of the DeepLabV3 model which outputs a tensor of size [21, width, height] for an input image of width*height. Each element in the width*height output array is a value between 0 and 20 (for a total of 21 semantic labels described in Introduction) and the value is used to set a specific color. Color coding of the segmentation here is based on the class with the highest probability, and you can extend the color coding for all classes in your own dataset.
-
-After the output processing, you will also need to call the code below to render the RGB `intValues` array to a bitmap instance `outputBitmap` before displaying it on an `ImageView`:
-
-.. code-block:: java
-
-    Bitmap bmpSegmentation = Bitmap.createScaledBitmap(bitmap, width, height, true);
-    Bitmap outputBitmap = bmpSegmentation.copy(bmpSegmentation.getConfig(), true);
-    outputBitmap.setPixels(intValues, 0, outputBitmap.getWidth(), 0, 0,
-        outputBitmap.getWidth(), outputBitmap.getHeight());
-    imageView.setImageBitmap(outputBitmap);
-
-The UI for this app is also similar to that for Hello World, except that you do not need the `TextView` to show the image classification result. You can also add two buttons `Segment` and `Restart` as shown in the code repository to run the model inference and to show back the original image after the segmentation result is shown.
-
-Now when you run the app on an Android emulator or preferably an actual device, you will see screens like the following:
-
-.. image:: /_static/img/deeplabv3_android.png
-   :width: 300 px
-.. image:: /_static/img/deeplabv3_android2.png
-   :width: 300 px
-
-
-Recap
---------
-
-In this tutorial, we described what it takes to convert a pretrained PyTorch DeepLabV3 model for Android and how to make sure the model can run successfully on Android. Our focus was to help you understand the process of confirming that a model can indeed run on Android. The complete code repository is available `here <https://github.com/pytorch/android-demo-app/tree/master/ImageSegmentation>`_.
-
-More advanced topics such as quantization and using models via transfer learning or of your own on Android will be covered soon in future demo apps and tutorials.
-
-
-Learn More
-------------
-
-1. `PyTorch Mobile site <https://pytorch.org/mobile>`_
-2. `DeepLabV3 model <https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101>`_
-3. `DeepLabV3 paper <https://arxiv.org/pdf/1706.05587.pdf>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/beginner_source/deeplabv3_on_ios.rst b/beginner_source/deeplabv3_on_ios.rst
index 5a88c703bd..66c052419f 100644
--- a/beginner_source/deeplabv3_on_ios.rst
+++ b/beginner_source/deeplabv3_on_ios.rst
@@ -1,248 +1,10 @@
 Image Segmentation DeepLabV3 on iOS
 ==============================================
 
-**Author**: `Jeff Tang <https://github.com/jeffxtang>`_
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-**Reviewed by**: `Jeremiah Chung <https://github.com/jeremiahschung>`_
+Redirecting in 3 seconds...
 
-Introduction
-------------
+.. raw:: html
 
-Semantic image segmentation is a computer vision task that uses semantic labels to mark specific regions of an input image. The PyTorch semantic image segmentation `DeepLabV3 model <https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101>`_ can be used to label image regions with `20 semantic classes <http://host.robots.ox.ac.uk:8080/pascal/VOC/voc2007/segexamples/index.html>`_ including, for example, bicycle, bus, car, dog, and person. Image segmentation models can be very useful in applications such as autonomous driving and scene understanding.
-
-In this tutorial, we will provide a step-by-step guide on how to prepare and run the PyTorch DeepLabV3 model on iOS, taking you from the beginning of having a model you may want to use on iOS to the end of having a complete iOS app using the model. We will also cover practical and general tips on how to check if your next favorite pretrained PyTorch models can run on iOS, and how to avoid pitfalls.
-
-.. note:: Before going through this tutorial, you should check out `PyTorch Mobile for iOS <https://pytorch.org/mobile/ios/>`_ and give the PyTorch iOS `HelloWorld <https://github.com/pytorch/ios-demo-app/tree/master/HelloWorld>`_ example app a quick try. This tutorial will go beyond the image classification model, usually the first kind of model deployed on mobile. The complete code for this tutorial is available `here <https://github.com/pytorch/ios-demo-app/tree/master/ImageSegmentation>`_.
-
-Learning Objectives
--------------------
-
-In this tutorial, you will learn how to:
-
-1. Convert the DeepLabV3 model for iOS deployment.
-
-2. Get the output of the model for the example input image in Python and compare it to the output from the iOS app.
-
-3. Build a new iOS app or reuse an iOS example app to load the converted model.
-
-4. Prepare the input into the format that the model expects and process the model output.
-
-5. Complete the UI, refactor, build and run the app to see image segmentation in action.
-
-Prerequisites
----------------
-
-* PyTorch 1.6 or 1.7
-
-* torchvision 0.7 or 0.8
-
-* Xcode 11 or 12
-
-Steps
----------
-
-
-1. Convert the DeepLabV3 model for iOS deployment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The first step to deploying a model on iOS is to convert the model into the `TorchScript <https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html>`_ format.
-
-.. note::
-    Not all PyTorch models can be converted to TorchScript at this time because a model definition may use language features that are not in TorchScript, which is a subset of Python. See the `Script and Optimize Recipe <../recipes/script_optimized.html>`_ for more details.
-
-Simply run the script below to generate the scripted model `deeplabv3_scripted.pt`:
-
-::
-
-    import torch
-
-    # use deeplabv3_resnet50 instead of deeplabv3_resnet101 to reduce the model size
-    model = torch.hub.load('pytorch/vision:v0.8.0', 'deeplabv3_resnet50', pretrained=True)
-    model.eval()
-
-    scriptedm = torch.jit.script(model)
-    torch.jit.save(scriptedm, "deeplabv3_scripted.pt")
-
-The size of the generated `deeplabv3_scripted.pt` model file should be around 168MB. Ideally, a model should also be quantized for significant size reduction and faster inference before being deployed on an iOS app. To have a general understanding of quantization, see the `Quantization Recipe <../recipes/quantization.html>`_ and the resource links there. We will cover in detail how to correctly apply a quantization workflow called Post Training `Static Quantization <https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html>`_ to the DeepLabV3 model in a future tutorial or recipe.
-
-2. Get example input and output of the model in Python
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Now that we have a scripted PyTorch model, let's test with some example inputs to make sure the model works correctly on iOS. First, let's write a Python script that uses the model to make inferences and examine inputs and outputs. For this example of the DeepLabV3 model, we can reuse the code in Step 1 and in the `DeepLabV3 model hub site <https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101>`_. Add the following code snippet to the code above:
-
-::
-
-    from PIL import Image
-    from torchvision import transforms
-    input_image = Image.open("deeplab.jpg")
-    preprocess = transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-    ])
-
-    input_tensor = preprocess(input_image)
-    input_batch = input_tensor.unsqueeze(0)
-    with torch.no_grad():
-        output = model(input_batch)['out'][0]
-
-    print(input_batch.shape)
-    print(output.shape)
-
-Download `deeplab.jpg` from `here <https://github.com/pytorch/ios-demo-app/blob/master/ImageSegmentation/ImageSegmentation/deeplab.jpg>`_ and run the script above to see the shapes of the input and output of the model:
-
-::
-
-    torch.Size([1, 3, 400, 400])
-    torch.Size([21, 400, 400])
-
-So if you provide the same image input `deeplab.jpg` of size 400x400 to the model on iOS, the output of the model should have the size [21, 400, 400]. You should also print out at least the beginning parts of the actual data of the input and output, to be used in Step 4 below to compare with the actual input and output of the model when running in the iOS app.
-
-3. Build a new iOS app or reuse an example app and load the model
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-First, follow Step 3 of the `Model Preparation for iOS recipe <../recipes/model_preparation_ios.html#add-the-model-and-pytorch-library-on-ios>`_ to use our model in an Xcode project with PyTorch Mobile enabled. Because both the DeepLabV3 model used in this tutorial and the MobileNet v2 model used in the PyTorch Hello World iOS example are computer vision models, you may choose to start with the `HelloWorld example repo <https://github.com/pytorch/ios-demo-app/tree/master/HelloWorld>`_ as a template to reuse the code that loads the model and processes the input and output.
-
-Now let's add `deeplabv3_scripted.pt` and `deeplab.jpg` used in Step 2 to the Xcode project and modify `ViewController.swift` to resemble:
-
-.. code-block:: swift
-
-    class ViewController: UIViewController {
-        var image = UIImage(named: "deeplab.jpg")!
-
-        override func viewDidLoad() {
-            super.viewDidLoad()
-        }
-
-        private lazy var module: TorchModule = {
-            if let filePath = Bundle.main.path(forResource: "deeplabv3_scripted",
-                  ofType: "pt"),
-                let module = TorchModule(fileAtPath: filePath) {
-                return module
-            } else {
-                fatalError("Can't load the model file!")
-            }
-        }()
-    }
-
-Then set a breakpoint at the line `return module` and build and run the app. The app should stop at the breakpoint, meaning that the scripted model in Step 1 has been successfully loaded on iOS.
-
-4. Process the model input and output for model inference
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-After the model loads in the previous step, let's verify that it works with expected inputs and can generate expected outputs. As the model input for the DeepLabV3 model is an image, the same as that of the MobileNet v2 in the Hello World example, we will reuse some of the code in the `TorchModule.mm <https://github.com/pytorch/ios-demo-app/blob/master/HelloWorld/HelloWorld/HelloWorld/TorchBridge/TorchModule.mm>`_ file from Hello World for input processing. Replace the `predictImage` method implementation in `TorchModule.mm` with the following code:
-
-.. code-block:: objective-c
-
-    - (unsigned char*)predictImage:(void*)imageBuffer {
-        // 1. the example deeplab.jpg size is size 400x400 and there are 21 semantic classes
-        const int WIDTH = 400;
-        const int HEIGHT = 400;
-        const int CLASSNUM = 21;
-
-        at::Tensor tensor = torch::from_blob(imageBuffer, {1, 3, WIDTH, HEIGHT}, at::kFloat);
-        torch::autograd::AutoGradMode guard(false);
-        at::AutoNonVariableTypeMode non_var_type_mode(true);
-
-        // 2. convert the input tensor to an NSMutableArray for debugging
-        float* floatInput = tensor.data_ptr<float>();
-        if (!floatInput) {
-            return nil;
-        }
-        NSMutableArray* inputs = [[NSMutableArray alloc] init];
-        for (int i = 0; i < 3 * WIDTH * HEIGHT; i++) {
-            [inputs addObject:@(floatInput[i])];
-        }
-
-        // 3. the output of the model is a dictionary of string and tensor, as
-        // specified at https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101
-        auto outputDict = _impl.forward({tensor}).toGenericDict();
-
-        // 4. convert the output to another NSMutableArray for easy debugging
-        auto outputTensor = outputDict.at("out").toTensor();
-        float* floatBuffer = outputTensor.data_ptr<float>();
-        if (!floatBuffer) {
-          return nil;
-        }
-        NSMutableArray* results = [[NSMutableArray alloc] init];
-        for (int i = 0; i < CLASSNUM * WIDTH * HEIGHT; i++) {
-          [results addObject:@(floatBuffer[i])];
-        }
-
-        return nil;
-    }
-
-.. note::
-    The model output is a dictionary for the DeepLabV3 model so we use `toGenericDict` to correctly extract the result. For other models, the model output may also be a single tensor or a tuple of tensors, among other things.
-
-With the code changes shown above, you can set breakpoints after the two for loops that populate `inputs` and `results` and compare them with the model input and output data you saw in Step 2 to see if they match. For the same inputs to the models running on iOS and Python, you should get the same outputs.
-
-All we have done so far is to confirm that the model of our interest can be scripted and run correctly in our iOS app as in Python. The steps we walked through so far for using a model in an iOS app consumes the bulk, if not most, of our app development time, similar to how data preprocessing is the heaviest lift for a typical machine learning project.
-
-5. Complete the UI, refactor, build and run the app
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Now we are ready to complete the app and the UI to actually see the processed result as a new image. The output processing code should be like this, added to the end of the code snippet in Step 4 in `TorchModule.mm` - remember to first remove the line `return nil;` temporarily put there to make the code build and run:
-
-.. code-block:: objective-c
-
-    // see the 20 semantic classes link in Introduction
-    const int DOG = 12;
-    const int PERSON = 15;
-    const int SHEEP = 17;
-
-    NSMutableData* data = [NSMutableData dataWithLength:
-        sizeof(unsigned char) * 3 * WIDTH * HEIGHT];
-    unsigned char* buffer = (unsigned char*)[data mutableBytes];
-    // go through each element in the output of size [WIDTH, HEIGHT] and
-    // set different color for different classnum
-    for (int j = 0; j < WIDTH; j++) {
-        for (int k = 0; k < HEIGHT; k++) {
-            // maxi: the index of the 21 CLASSNUM with the max probability
-            int maxi = 0, maxj = 0, maxk = 0;
-            float maxnum = -100000.0;
-            for (int i = 0; i < CLASSNUM; i++) {
-                if ([results[i * (WIDTH * HEIGHT) + j * WIDTH + k] floatValue] > maxnum) {
-                    maxnum = [results[i * (WIDTH * HEIGHT) + j * WIDTH + k] floatValue];
-                    maxi = i; maxj = j; maxk = k;
-                }
-            }
-            int n = 3 * (maxj * width + maxk);
-            // color coding for person (red), dog (green), sheep (blue)
-            // black color for background and other classes
-            buffer[n] = 0; buffer[n+1] = 0; buffer[n+2] = 0;
-            if (maxi == PERSON) buffer[n] = 255;
-            else if (maxi == DOG) buffer[n+1] = 255;
-            else if (maxi == SHEEP) buffer[n+2] = 255;
-        }
-    }
-    return buffer;
-
-The implementation here is based on the understanding of the DeepLabV3 model which outputs a tensor of size [21, width, height] for an input image of width*height. Each element in the width*height output array is a value between 0 and 20 (for a total of 21 semantic labels described in Introduction) and the value is used to set a specific color. Color coding of the segmentation here is based on the class with the highest probability, and you can extend the color coding for all classes in your own dataset.
-
-After the output processing, you will also need to call a helper function to convert the RGB `buffer` to an `UIImage` instance to be shown on `UIImageView`. You can refer to the example code `convertRGBBufferToUIImage` defined in `UIImageHelper.mm` in the code repository.
-
-The UI for this app is also similar to that for Hello World, except that you do not need the `UITextView` to show the image classification result. You can also add two buttons `Segment` and `Restart` as shown in the code repository to run the model inference and to show back the original image after the segmentation result is shown.
-
-The last step before we can run the app is to connect all the pieces together. Modify the `ViewController.swift` file to use the `predictImage`, which is refactored and changed to `segmentImage` in the repository, and helper functions you built as shown in the example code in the repository in `ViewController.swift`. Connect the buttons to the actions and you should be good to go.
-
-Now when you run the app on an iOS simulator or an actual iOS device, you will see the following screens:
-
-.. image:: /_static/img/deeplabv3_ios.png
-   :width: 300 px
-.. image:: /_static/img/deeplabv3_ios2.png
-   :width: 300 px
-
-
-Recap
---------
-
-In this tutorial, we described what it takes to convert a pretrained PyTorch DeepLabV3 model for iOS and how to make sure the model can run successfully on iOS. Our focus was to help you understand the process of confirming that a model can indeed run on iOS. The complete code repository is available `here <https://github.com/pytorch/ios-demo-app/tree/master/ImageSegmentation>`_.
-
-More advanced topics such as quantization and using models via transfer learning or of your own on iOS will be covered soon in future demo apps and tutorials.
-
-Learn More
-------------
-
-1. `PyTorch Mobile site <https://pytorch.org/mobile>`_
-2. `DeepLabV3 model <https://pytorch.org/hub/pytorch_vision_deeplabv3_resnet101>`_
-3. `DeepLabV3 paper <https://arxiv.org/pdf/1706.05587.pdf>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/beginner_source/deploy_seq2seq_hybrid_frontend_tutorial.py b/beginner_source/deploy_seq2seq_hybrid_frontend_tutorial.py
index 508fa5a057..c36380b0f5 100644
--- a/beginner_source/deploy_seq2seq_hybrid_frontend_tutorial.py
+++ b/beginner_source/deploy_seq2seq_hybrid_frontend_tutorial.py
@@ -3,6 +3,8 @@
 Deploying a Seq2Seq Model with TorchScript
 ==================================================
 **Author:** `Matthew Inkawhich <https://github.com/MatthewInkawhich>`_
+
+.. note:: TorchScript is no longer in active development.
 """
 
 
diff --git a/beginner_source/former_torchies/README.txt b/beginner_source/former_torchies/README.txt
deleted file mode 100644
index 5bb8c93f00..0000000000
--- a/beginner_source/former_torchies/README.txt
+++ /dev/null
@@ -1,18 +0,0 @@
- PyTorch for former Torch users
- ------------------------------
- 
-1. tensor_tutorial_old.py
-	Tensors
-	https://pytorch.org/tutorials/beginner/former_torchies/tensor_tutorial_old.html
-
-2. autograd_tutorial_old.py
-	Autograd
-	https://pytorch.org/tutorials/beginner/former_torchies/autograd_tutorial_old.html
-
-3. nnft_tutorial.py
-	nn package
-	https://pytorch.org/tutorials/beginner/former_torchies/nnft_tutorial.html
-
-4. parallelism_tutorial.py
-	Multi-GPU examples
-	https://pytorch.org/tutorials/beginner/former_torchies/parallelism_tutorial.html
diff --git a/beginner_source/former_torchies/autograd_tutorial_old.py b/beginner_source/former_torchies/autograd_tutorial_old.py
deleted file mode 100644
index 4030831b8e..0000000000
--- a/beginner_source/former_torchies/autograd_tutorial_old.py
+++ /dev/null
@@ -1,130 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Autograd
-========
-
-Autograd is now a core torch package for automatic differentiation.
-It uses a tape based system for automatic differentiation.
-
-In the forward phase, the autograd tape will remember all the operations
-it executed, and in the backward phase, it will replay the operations.
-
-Tensors that track history
---------------------------
-
-In autograd, if any input ``Tensor`` of an operation has ``requires_grad=True``,
-the computation will be tracked. After computing the backward pass, a gradient
-w.r.t. this tensor is accumulated into ``.grad`` attribute.
-
-There’s one more class which is very important for autograd
-implementation - a ``Function``. ``Tensor`` and ``Function`` are
-interconnected and build up an acyclic graph, that encodes a complete
-history of computation. Each variable has a ``.grad_fn`` attribute that
-references a function that has created a function (except for Tensors
-created by the user - these have ``None`` as ``.grad_fn``).
-
-If you want to compute the derivatives, you can call ``.backward()`` on
-a ``Tensor``. If ``Tensor`` is a scalar (i.e. it holds a one element
-tensor), you don’t need to specify any arguments to ``backward()``,
-however if it has more elements, you need to specify a ``grad_output``
-argument that is a tensor of matching shape.
-"""
-
-import torch
-
-###############################################################
-# Create a tensor and set requires_grad=True to track computation with it
-x = torch.ones(2, 2, requires_grad=True)
-print(x)
-
-###############################################################
-#
-print(x.data)
-
-###############################################################
-#
-print(x.grad)
-
-###############################################################
-#
-
-print(x.grad_fn)  # we've created x ourselves
-
-###############################################################
-# Do an operation of x:
-
-y = x + 2
-print(y)
-
-###############################################################
-# y was created as a result of an operation,
-# so it has a grad_fn
-print(y.grad_fn)
-
-###############################################################
-# More operations on y:
-
-z = y * y * 3
-out = z.mean()
-
-print(z, out)
-
-################################################################
-# ``.requires_grad_( ... )`` changes an existing Tensor's ``requires_grad``
-# flag in-place. The input flag defaults to ``True`` if not given.
-a = torch.randn(2, 2)
-a = ((a * 3) / (a - 1))
-print(a.requires_grad)
-a.requires_grad_(True)
-print(a.requires_grad)
-b = (a * a).sum()
-print(b.grad_fn)
-
-###############################################################
-# Gradients
-# ---------
-#
-# let's backprop now and print gradients d(out)/dx
-
-out.backward()
-print(x.grad)
-
-
-###############################################################
-# By default, gradient computation flushes all the internal buffers
-# contained in the graph, so if you even want to do the backward on some
-# part of the graph twice, you need to pass in ``retain_variables = True``
-# during the first pass.
-
-x = torch.ones(2, 2, requires_grad=True)
-y = x + 2
-y.backward(torch.ones(2, 2), retain_graph=True)
-# the retain_variables flag will prevent the internal buffers from being freed
-print(x.grad)
-
-###############################################################
-#
-z = y * y
-print(z)
-
-###############################################################
-#
-# just backprop random gradients
-
-gradient = torch.randn(2, 2)
-
-# this would fail if we didn't specify
-# that we want to retain variables
-y.backward(gradient)
-
-print(x.grad)
-
-###############################################################
-# You can also stop autograd from tracking history on Tensors
-# with requires_grad=True by wrapping the code block in
-# ``with torch.no_grad():``
-print(x.requires_grad)
-print((x ** 2).requires_grad)
-
-with torch.no_grad():
-	print((x ** 2).requires_grad)
diff --git a/beginner_source/former_torchies/autograd_tutorial_old.rst b/beginner_source/former_torchies/autograd_tutorial_old.rst
new file mode 100644
index 0000000000..8c887e00c8
--- /dev/null
+++ b/beginner_source/former_torchies/autograd_tutorial_old.rst
@@ -0,0 +1,8 @@
+Autograd
+==============
+
+This tutorial is out of date. You'll be redirected to the new tutorial in 3 seconds: https://pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html'" />
diff --git a/beginner_source/former_torchies/nnft_tutorial.py b/beginner_source/former_torchies/nnft_tutorial.py
deleted file mode 100644
index 316bf03a98..0000000000
--- a/beginner_source/former_torchies/nnft_tutorial.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-nn package
-==========
-
-We’ve redesigned the nn package, so that it’s fully integrated with
-autograd. Let's review the changes.
-
-**Replace containers with autograd:**
-
-    You no longer have to use Containers like ``ConcatTable``, or modules like
-    ``CAddTable``, or use and debug with nngraph. We will seamlessly use
-    autograd to define our neural networks. For example,
-
-    * ``output = nn.CAddTable():forward({input1, input2})`` simply becomes
-      ``output = input1 + input2``
-    * ``output = nn.MulConstant(0.5):forward(input)`` simply becomes
-      ``output = input * 0.5``
-
-**State is no longer held in the module, but in the network graph:**
-
-    Using recurrent networks should be simpler because of this reason. If
-    you want to create a recurrent network, simply use the same Linear layer
-    multiple times, without having to think about sharing weights.
-
-    .. figure:: /_static/img/torch-nn-vs-pytorch-nn.png
-       :alt: torch-nn-vs-pytorch-nn
-
-       torch-nn-vs-pytorch-nn
-
-**Simplified debugging:**
-
-    Debugging is intuitive using Python’s pdb debugger, and **the debugger
-    and stack traces stop at exactly where an error occurred.** What you see
-    is what you get.
-
-Example 1: ConvNet
-------------------
-
-Let’s see how to create a small ConvNet.
-
-All of your networks are derived from the base class ``nn.Module``:
-
--  In the constructor, you declare all the layers you want to use.
--  In the forward function, you define how your model is going to be
-   run, from input to output
-"""
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class MNISTConvNet(nn.Module):
-
-    def __init__(self):
-        # this is the place where you instantiate all your modules
-        # you can later access them using the same names you've given them in
-        # here
-        super(MNISTConvNet, self).__init__()
-        self.conv1 = nn.Conv2d(1, 10, 5)
-        self.pool1 = nn.MaxPool2d(2, 2)
-        self.conv2 = nn.Conv2d(10, 20, 5)
-        self.pool2 = nn.MaxPool2d(2, 2)
-        self.fc1 = nn.Linear(320, 50)
-        self.fc2 = nn.Linear(50, 10)
-
-    # it's the forward function that defines the network structure
-    # we're accepting only a single input in here, but if you want,
-    # feel free to use more
-    def forward(self, input):
-        x = self.pool1(F.relu(self.conv1(input)))
-        x = self.pool2(F.relu(self.conv2(x)))
-
-        # in your model definition you can go full crazy and use arbitrary
-        # python code to define your model structure
-        # all these are perfectly legal, and will be handled correctly
-        # by autograd:
-        # if x.gt(0) > x.numel() / 2:
-        #      ...
-        #
-        # you can even do a loop and reuse the same module inside it
-        # modules no longer hold ephemeral state, so you can use them
-        # multiple times during your forward pass
-        # while x.norm(2) < 10:
-        #    x = self.conv1(x)
-
-        x = x.view(x.size(0), -1)
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        return x
-
-###############################################################
-# Let's use the defined ConvNet now.
-# You create an instance of the class first.
-
-
-net = MNISTConvNet()
-print(net)
-
-########################################################################
-# .. note::
-#
-#     ``torch.nn`` only supports mini-batches The entire ``torch.nn``
-#     package only supports inputs that are a mini-batch of samples, and not
-#     a single sample.
-#
-#     For example, ``nn.Conv2d`` will take in a 4D Tensor of
-#     ``nSamples x nChannels x Height x Width``.
-#
-#     If you have a single sample, just use ``input.unsqueeze(0)`` to add
-#     a fake batch dimension.
-#
-# Create a mini-batch containing a single sample of random data and send the
-# sample through the ConvNet.
-
-input = torch.randn(1, 1, 28, 28)
-out = net(input)
-print(out.size())
-
-########################################################################
-# Define a dummy target label and compute error using a loss function.
-
-target = torch.tensor([3], dtype=torch.long)
-loss_fn = nn.CrossEntropyLoss()  # LogSoftmax + ClassNLL Loss
-err = loss_fn(out, target)
-err.backward()
-
-print(err)
-
-########################################################################
-# The output of the ConvNet ``out`` is a ``Tensor``. We compute the loss
-# using that, and that results in ``err`` which is also a ``Tensor``.
-# Calling ``.backward`` on ``err`` hence will propagate gradients all the
-# way through the ConvNet to it’s weights
-#
-# Let's access individual layer weights and gradients:
-
-print(net.conv1.weight.grad.size())
-
-########################################################################
-print(net.conv1.weight.data.norm())  # norm of the weight
-print(net.conv1.weight.grad.data.norm())  # norm of the gradients
-
-########################################################################
-# Forward and Backward Function Hooks
-# -----------------------------------
-#
-# We’ve inspected the weights and the gradients. But how about inspecting
-# / modifying the output and grad\_output of a layer?
-#
-# We introduce **hooks** for this purpose.
-#
-# You can register a function on a ``Module`` or a ``Tensor``.
-# The hook can be a forward hook or a backward hook.
-# The forward hook will be executed when a forward call is executed.
-# The backward hook will be executed in the backward phase.
-# Let’s look at an example.
-#
-# We register a forward hook on conv2 and print some information
-
-
-def printnorm(self, input, output):
-    # input is a tuple of packed inputs
-    # output is a Tensor. output.data is the Tensor we are interested
-    print('Inside ' + self.__class__.__name__ + ' forward')
-    print('')
-    print('input: ', type(input))
-    print('input[0]: ', type(input[0]))
-    print('output: ', type(output))
-    print('')
-    print('input size:', input[0].size())
-    print('output size:', output.data.size())
-    print('output norm:', output.data.norm())
-
-
-net.conv2.register_forward_hook(printnorm)
-
-out = net(input)
-
-########################################################################
-#
-# We register a backward hook on conv2 and print some information
-
-
-def printgradnorm(self, grad_input, grad_output):
-    print('Inside ' + self.__class__.__name__ + ' backward')
-    print('Inside class:' + self.__class__.__name__)
-    print('')
-    print('grad_input: ', type(grad_input))
-    print('grad_input[0]: ', type(grad_input[0]))
-    print('grad_output: ', type(grad_output))
-    print('grad_output[0]: ', type(grad_output[0]))
-    print('')
-    print('grad_input size:', grad_input[0].size())
-    print('grad_output size:', grad_output[0].size())
-    print('grad_input norm:', grad_input[0].norm())
-
-
-net.conv2.register_backward_hook(printgradnorm)
-
-out = net(input)
-err = loss_fn(out, target)
-err.backward()
-
-########################################################################
-# A full and working MNIST example is located here
-# https://github.com/pytorch/examples/tree/master/mnist
-#
-# Example 2: Recurrent Net
-# ------------------------
-#
-# Next, let’s look at building recurrent nets with PyTorch.
-#
-# Since the state of the network is held in the graph and not in the
-# layers, you can simply create an nn.Linear and reuse it over and over
-# again for the recurrence.
-
-
-class RNN(nn.Module):
-
-    # you can also accept arguments in your model constructor
-    def __init__(self, data_size, hidden_size, output_size):
-        super(RNN, self).__init__()
-
-        self.hidden_size = hidden_size
-        input_size = data_size + hidden_size
-
-        self.i2h = nn.Linear(input_size, hidden_size)
-        self.h2o = nn.Linear(hidden_size, output_size)
-
-    def forward(self, data, last_hidden):
-        input = torch.cat((data, last_hidden), 1)
-        hidden = self.i2h(input)
-        output = self.h2o(hidden)
-        return hidden, output
-
-
-rnn = RNN(50, 20, 10)
-
-########################################################################
-#
-# A more complete Language Modeling example using LSTMs and Penn Tree-bank
-# is located
-# `here <https://github.com/pytorch/examples/tree/master/word\_language\_model>`_
-#
-# PyTorch by default has seamless CuDNN integration for ConvNets and
-# Recurrent Nets
-
-loss_fn = nn.MSELoss()
-
-batch_size = 10
-TIMESTEPS = 5
-
-# Create some fake data
-batch = torch.randn(batch_size, 50)
-hidden = torch.zeros(batch_size, 20)
-target = torch.zeros(batch_size, 10)
-
-loss = 0
-for t in range(TIMESTEPS):
-    # yes! you can reuse the same network several times,
-    # sum up the losses, and call backward!
-    hidden, output = rnn(batch, hidden)
-    loss += loss_fn(output, target)
-loss.backward()
diff --git a/beginner_source/former_torchies/nnft_tutorial.rst b/beginner_source/former_torchies/nnft_tutorial.rst
new file mode 100644
index 0000000000..db378a7162
--- /dev/null
+++ b/beginner_source/former_torchies/nnft_tutorial.rst
@@ -0,0 +1,8 @@
+nn Package
+===============
+
+This tutorial is out of date. You'll be redirected to the new tutorial in 3 seconds: https://pytorch.org/tutorials/beginner/nn_tutorial.html
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/nn_tutorial.html'" />
diff --git a/beginner_source/former_torchies/parallelism_tutorial.py b/beginner_source/former_torchies/parallelism_tutorial.py
deleted file mode 100644
index a11d844e1b..0000000000
--- a/beginner_source/former_torchies/parallelism_tutorial.py
+++ /dev/null
@@ -1,145 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Multi-GPU Examples
-==================
-
-Data Parallelism is when we split the mini-batch of samples into
-multiple smaller mini-batches and run the computation for each of the
-smaller mini-batches in parallel.
-
-Data Parallelism is implemented using ``torch.nn.DataParallel``.
-One can wrap a Module in ``DataParallel`` and it will be parallelized
-over multiple GPUs in the batch dimension.
-
-
-DataParallel
--------------
-"""
-import torch
-import torch.nn as nn
-
-
-class DataParallelModel(nn.Module):
-
-    def __init__(self):
-        super().__init__()
-        self.block1 = nn.Linear(10, 20)
-
-        # wrap block2 in DataParallel
-        self.block2 = nn.Linear(20, 20)
-        self.block2 = nn.DataParallel(self.block2)
-
-        self.block3 = nn.Linear(20, 20)
-
-    def forward(self, x):
-        x = self.block1(x)
-        x = self.block2(x)
-        x = self.block3(x)
-        return x
-
-########################################################################
-# The code does not need to be changed in CPU-mode.
-#
-# The documentation for DataParallel can be found
-# `here <https://pytorch.org/docs/stable/nn.html#dataparallel-layers-multi-gpu-distributed>`_.
-# 
-# **Attributes of the wrapped module**
-# 
-# After wrapping a Module with ``DataParallel``, the attributes of the module
-# (e.g. custom methods) became inaccessible. This is because ``DataParallel``
-# defines a few new members, and allowing other attributes might lead to 
-# clashes in their names. For those who still want to access the attributes, 
-# a workaround is to use a subclass of ``DataParallel`` as below.
-
-class MyDataParallel(nn.DataParallel):
-    def __getattr__(self, name):
-        try:
-            return super().__getattr__(name)
-        except AttributeError:
-            return getattr(self.module, name)
-    
-########################################################################
-# **Primitives on which DataParallel is implemented upon:**
-#
-#
-# In general, pytorch’s `nn.parallel` primitives can be used independently.
-# We have implemented simple MPI-like primitives:
-#
-# - replicate: replicate a Module on multiple devices
-# - scatter: distribute the input in the first-dimension
-# - gather: gather and concatenate the input in the first-dimension
-# - parallel\_apply: apply a set of already-distributed inputs to a set of
-#   already-distributed models.
-#
-# To give a better clarity, here function ``data_parallel`` composed using
-# these collectives
-
-
-def data_parallel(module, input, device_ids, output_device=None):
-    if not device_ids:
-        return module(input)
-
-    if output_device is None:
-        output_device = device_ids[0]
-
-    replicas = nn.parallel.replicate(module, device_ids)
-    inputs = nn.parallel.scatter(input, device_ids)
-    replicas = replicas[:len(inputs)]
-    outputs = nn.parallel.parallel_apply(replicas, inputs)
-    return nn.parallel.gather(outputs, output_device)
-
-########################################################################
-# Part of the model on CPU and part on the GPU
-# --------------------------------------------
-#
-# Let’s look at a small example of implementing a network where part of it
-# is on the CPU and part on the GPU
-
-device = torch.device("cuda:0")
-
-class DistributedModel(nn.Module):
-
-    def __init__(self):
-        super().__init__(
-            embedding=nn.Embedding(1000, 10),
-            rnn=nn.Linear(10, 10).to(device),
-        )
-
-    def forward(self, x):
-        # Compute embedding on CPU
-        x = self.embedding(x)
-
-        # Transfer to GPU
-        x = x.to(device)
-
-        # Compute RNN on GPU
-        x = self.rnn(x)
-        return x
-
-########################################################################
-#
-# This was a small introduction to PyTorch for former Torch users.
-# There’s a lot more to learn.
-#
-# Look at our more comprehensive introductory tutorial which introduces
-# the ``optim`` package, data loaders etc.: :doc:`/beginner/deep_learning_60min_blitz`.
-#
-# Also look at
-#
-# -  :doc:`Train neural nets to play video games </intermediate/reinforcement_q_learning>`
-# -  `Train a state-of-the-art ResNet network on imagenet`_
-# -  `Train a face generator using Generative Adversarial Networks`_
-# -  `Train a word-level language model using Recurrent LSTM networks`_
-# -  `More examples`_
-# -  `More tutorials`_
-# -  `Discuss PyTorch on the Forums`_
-# -  `Chat with other users on Slack`_
-#
-# .. _`Deep Learning with PyTorch: a 60-minute blitz`: https://github.com/pytorch/tutorials/blob/main/Deep%20Learning%20with%20PyTorch.ipynb
-# .. _Train a state-of-the-art ResNet network on imagenet: https://github.com/pytorch/examples/tree/master/imagenet
-# .. _Train a face generator using Generative Adversarial Networks: https://github.com/pytorch/examples/tree/master/dcgan
-# .. _Train a word-level language model using Recurrent LSTM networks: https://github.com/pytorch/examples/tree/master/word_language_model
-# .. _More examples: https://github.com/pytorch/examples
-# .. _More tutorials: https://github.com/pytorch/tutorials
-# .. _Discuss PyTorch on the Forums: https://discuss.pytorch.org/
-# .. _Chat with other users on Slack: https://pytorch.slack.com/messages/beginner/
diff --git a/beginner_source/former_torchies/parallelism_tutorial.rst b/beginner_source/former_torchies/parallelism_tutorial.rst
new file mode 100644
index 0000000000..04bb1d69e5
--- /dev/null
+++ b/beginner_source/former_torchies/parallelism_tutorial.rst
@@ -0,0 +1,8 @@
+Multi-GPU Examples
+==============
+
+This tutorial is out of date. You'll be redirected to the new tutorial in 3 seconds: https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html'" />
diff --git a/beginner_source/former_torchies/tensor_tutorial_old.py b/beginner_source/former_torchies/tensor_tutorial_old.py
deleted file mode 100644
index 10a9d81fad..0000000000
--- a/beginner_source/former_torchies/tensor_tutorial_old.py
+++ /dev/null
@@ -1,143 +0,0 @@
-"""
-Tensors
-=======
-
-Tensors behave almost exactly the same way in PyTorch as they do in
-Torch.
-
-Create a tensor of size (5 x 7) with uninitialized memory:
-
-"""
-
-import torch
-a = torch.empty(5, 7, dtype=torch.float)
-
-###############################################################
-# Initialize a double tensor randomized with a normal distribution with mean=0,
-# var=1:
-
-a = torch.randn(5, 7, dtype=torch.double)
-print(a)
-print(a.size())
-
-###############################################################
-# .. note::
-#     ``torch.Size`` is in fact a tuple, so it supports the same operations
-#
-# Inplace / Out-of-place
-# ----------------------
-#
-# The first difference is that ALL operations on the tensor that operate
-# in-place on it will have an ``_`` postfix. For example, ``add`` is the
-# out-of-place version, and ``add_`` is the in-place version.
-
-a.fill_(3.5)
-# a has now been filled with the value 3.5
-
-b = a.add(4.0)
-# a is still filled with 3.5
-# new tensor b is returned with values 3.5 + 4.0 = 7.5
-
-print(a, b)
-
-###############################################################
-# Some operations like ``narrow`` do not have in-place versions, and
-# hence, ``.narrow_`` does not exist. Similarly, some operations like
-# ``fill_`` do not have an out-of-place version, so ``.fill`` does not
-# exist.
-#
-# Zero Indexing
-# -------------
-#
-# Another difference is that Tensors are zero-indexed. (In lua, tensors are
-# one-indexed)
-
-b = a[0, 3]  # select 1st row, 4th column from a
-
-###############################################################
-# Tensors can be also indexed with Python's slicing
-
-b = a[:, 3:5]  # selects all rows, 4th column and  5th column from a
-
-###############################################################
-# No camel casing
-# ---------------
-#
-# The next small difference is that all functions are now NOT camelCase
-# anymore. For example ``indexAdd`` is now called ``index_add_``
-
-
-x = torch.ones(5, 5)
-print(x)
-
-###############################################################
-#
-
-z = torch.empty(5, 2)
-z[:, 0] = 10
-z[:, 1] = 100
-print(z)
-
-###############################################################
-#
-x.index_add_(1, torch.tensor([4, 0], dtype=torch.long), z)
-print(x)
-
-###############################################################
-# Numpy Bridge
-# ------------
-#
-# Converting a torch Tensor to a numpy array and vice versa is a breeze.
-# The torch Tensor and numpy array will share their underlying memory
-# locations, and changing one will change the other.
-#
-# Converting torch Tensor to numpy Array
-# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-a = torch.ones(5)
-print(a)
-
-###############################################################
-#
-
-b = a.numpy()
-print(b)
-
-###############################################################
-#
-a.add_(1)
-print(a)
-print(b) 	# see how the numpy array changed in value
-
-
-###############################################################
-# Converting numpy Array to torch Tensor
-# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-import numpy as np
-a = np.ones(5)
-b = torch.from_numpy(a)
-np.add(a, 1, out=a)
-print(a)
-print(b)  # see how changing the np array changed the torch Tensor automatically
-
-###############################################################
-# All the Tensors on the CPU except a CharTensor support converting to
-# NumPy and back.
-#
-# CUDA Tensors
-# ------------
-#
-# CUDA Tensors are nice and easy in pytorch, and transfering a CUDA tensor
-# from the CPU to GPU will retain its underlying type.
-
-# let us run this cell only if CUDA is available
-if torch.cuda.is_available():
-
-    # creates a LongTensor and transfers it
-    # to GPU as torch.cuda.LongTensor
-    a = torch.full((10,), 3, device=torch.device("cuda"))
-    print(type(a))
-    b = a.to(torch.device("cpu"))
-    # transfers it to CPU, back to
-    # being a torch.LongTensor
diff --git a/beginner_source/former_torchies/tensor_tutorial_old.rst b/beginner_source/former_torchies/tensor_tutorial_old.rst
new file mode 100644
index 0000000000..939a6855c2
--- /dev/null
+++ b/beginner_source/former_torchies/tensor_tutorial_old.rst
@@ -0,0 +1,8 @@
+Tensors
+==============
+
+This tutorial is out of date. You'll be redirected to the new tutorial in 3 seconds: https://pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.html
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.html'" />
diff --git a/beginner_source/former_torchies_tutorial.rst b/beginner_source/former_torchies_tutorial.rst
index e6ae59b708..5071a62e73 100644
--- a/beginner_source/former_torchies_tutorial.rst
+++ b/beginner_source/former_torchies_tutorial.rst
@@ -1,37 +1,9 @@
 PyTorch for Former Torch Users
-------------------------------
-**Author**: `Soumith Chintala <http://soumith.ch>`_
+==============
+This tutorial is out of date. Please check out the PyTorch tutorials here: https://pytorch.org/tutorials/
 
-In this tutorial, you will learn the following:
-
-1. Using torch Tensors, and important difference against (Lua)Torch
-2. Using the autograd package
-3. Building neural networks
-
-  -  Building a ConvNet
-  -  Building a Recurrent Net
-
-4. Use multiple GPUs
-
-
-.. toctree::
-   :hidden:
-
-   /beginner/former_torchies/tensor_tutorial_old
-   /beginner/former_torchies/autograd_tutorial_old
-   /beginner/former_torchies/nnft_tutorial
-   /beginner/former_torchies/parallelism_tutorial
-
-.. galleryitem:: /beginner/former_torchies/tensor_tutorial_old.py
-    :figure: /_static/img/tensor_illustration_flat.png
-
-.. galleryitem:: /beginner/former_torchies/autograd_tutorial_old.py
-
-.. galleryitem:: /beginner/former_torchies/nnft_tutorial.py
-    :figure: /_static/img/torch-nn-vs-pytorch-nn.png
-
-.. galleryitem:: /beginner/former_torchies/parallelism_tutorial.py
+You will be redirected in 3 seconds.
 
 .. raw:: html
 
-    <div style='clear:both'></div>
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/'" />
diff --git a/beginner_source/hyperparameter_tuning_tutorial.py b/beginner_source/hyperparameter_tuning_tutorial.py
index 2680d1a23c..aa84069f7b 100644
--- a/beginner_source/hyperparameter_tuning_tutorial.py
+++ b/beginner_source/hyperparameter_tuning_tutorial.py
@@ -10,7 +10,7 @@
 Fortunately, there are tools that help with finding the best combination of parameters.
 `Ray Tune <https://docs.ray.io/en/latest/tune.html>`_ is an industry standard tool for
 distributed hyperparameter tuning. Ray Tune includes the latest hyperparameter search
-algorithms, integrates with TensorBoard and other analysis libraries, and natively
+algorithms, integrates with various analysis libraries, and natively
 supports distributed training through `Ray's distributed machine learning engine
 <https://ray.io/>`_.
 
diff --git a/beginner_source/introyt.rst b/beginner_source/introyt.rst
index 841cc3cd28..9b2a630c24 100644
--- a/beginner_source/introyt.rst
+++ b/beginner_source/introyt.rst
@@ -1,29 +1,10 @@
-`Introduction <introyt/introyt1_tutorial.html>`_ ||
-`Tensors <introyt/tensors_deeper_tutorial.html>`_ ||
-`Autograd <introyt/autogradyt_tutorial.html>`_ ||
-`Building Models <introyt/modelsyt_tutorial.html>`_ ||
-`TensorBoard Support <introyt/tensorboardyt_tutorial.html>`_ ||
-`Training Models <introyt/trainingyt.html>`_ ||
-`Model Understanding <introyt/captumyt.html>`_
-
 Introduction to PyTorch - YouTube Series
 ========================================
 
-Authors: 
-`Brad Heintz <https://github.com/fbbradheintz>`_
-
-This tutorial follows along with the `PyTorch Beginner Series <https://www.youtube.com/playlist?list=PL_lsbAsL_o2CTlGHgMxNrKhzP97BaG9ZN>`_ on YouTube.
-
-`This tutorial assumes a basic familiarity with Python and Deep Learning concepts.`
-
-Running the Tutorial Code
--------------------------
-You can run this tutorial in a couple of ways:
+This page has been moved.
 
-- **In the cloud**: This is the easiest way to get started! Each section has a Colab link at the top, which opens a notebook with the code in a fully-hosted environment. Pro tip: Use Colab with a GPU runtime to speed up operations *Runtime > Change runtime type > GPU*
-- **Locally**: This option requires you to setup PyTorch and torchvision first on your local machine (`installation instructions <https://pytorch.org/get-started/locally/>`_). Download the notebook or copy the code into your favorite IDE.
+Redirecting now...
 
-.. include:: /beginner_source/introyt/tocyt.txt
+.. raw:: html
 
-.. toctree::
-   :hidden:
+   <meta http-equiv="Refresh" content="0; url='https://pytorch.org/tutorials/beginner/introyt/introyt_index.html'" />
diff --git a/beginner_source/introyt/README.txt b/beginner_source/introyt/README.txt
index ebe8f2e9c2..b90d269cfa 100644
--- a/beginner_source/introyt/README.txt
+++ b/beginner_source/introyt/README.txt
@@ -1,7 +1,7 @@
 Introduction to PyTorch on YouTube
 ----------------------------------
 
-1. introyt.rst
+1. introyt.py
     Introduction to PyTorch - Youtube Series
     https://pytorch.org/tutorials/beginner/introyt/introyt.html
 
diff --git a/beginner_source/introyt/introyt_index.py b/beginner_source/introyt/introyt_index.py
new file mode 100644
index 0000000000..63b9c053a3
--- /dev/null
+++ b/beginner_source/introyt/introyt_index.py
@@ -0,0 +1,38 @@
+"""
+`Introduction <introyt/introyt1_tutorial.html>`_ ||
+`Tensors <introyt/tensors_deeper_tutorial.html>`_ ||
+`Autograd <introyt/autogradyt_tutorial.html>`_ ||
+`Building Models <introyt/modelsyt_tutorial.html>`_ ||
+`TensorBoard Support <introyt/tensorboardyt_tutorial.html>`_ ||
+`Training Models <introyt/trainingyt.html>`_ ||
+`Model Understanding <introyt/captumyt.html>`_
+
+Introduction to PyTorch - YouTube Series
+========================================
+
+Authors:
+`Brad Heintz <https://github.com/fbbradheintz>`_
+
+This tutorial follows along with the `PyTorch Beginner Series <https://www.youtube.com/playlist?list=PL_lsbAsL_o2CTlGHgMxNrKhzP97BaG9ZN>`_ on YouTube.
+
+`This tutorial assumes a basic familiarity with Python and Deep Learning concepts.`
+
+Running the Tutorial Code
+-------------------------
+You can run this tutorial in a couple of ways:
+
+- **On the cloud**: This is the easiest way to get started! Each section has a Colab link at the top, which opens a notebook with the code in a fully-hosted environment. Pro tip: Use Colab with a GPU runtime to speed up operations *Runtime > Change runtime type > GPU*
+- **Locally**: This option requires you to set up PyTorch and torchvision on your local machine (`installation instructions <https://pytorch.org/get-started/locally/>`_). Download the notebook or copy the code into your favorite IDE.
+
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+
+   introyt1_tutorial
+   tensors_deeper_tutorial
+   autogradyt_tutorial
+   modelsyt_tutorial
+   tensorboardyt_tutorial
+   trainingyt
+   captumyt
+"""
diff --git a/beginner_source/ptcheat.rst b/beginner_source/ptcheat.rst
index 91a0586618..49f9c9f595 100644
--- a/beginner_source/ptcheat.rst
+++ b/beginner_source/ptcheat.rst
@@ -22,27 +22,12 @@ Neural Network API
     import torch.nn as nn                     # neural networks
     import torch.nn.functional as F           # layers, activations and more
     import torch.optim as optim               # optimizers e.g. gradient descent, ADAM, etc.
-    from torch.jit import script, trace       # hybrid frontend decorator and tracing jit
 
 See `autograd <https://pytorch.org/docs/stable/autograd.html>`__,
 `nn <https://pytorch.org/docs/stable/nn.html>`__,
 `functional <https://pytorch.org/docs/stable/nn.html#torch-nn-functional>`__
 and `optim <https://pytorch.org/docs/stable/optim.html>`__
 
-TorchScript and JIT
--------------------
-
-.. code-block:: python
-
-    torch.jit.trace()         # takes your module or function and an example 
-                              # data input, and traces the computational steps 
-                              # that the data encounters as it progresses through the model
-
-    @script                   # decorator used to indicate data-dependent 
-                              # control flow within the code being traced
-
-See `Torchscript <https://pytorch.org/docs/stable/jit.html>`__
-
 ONNX
 ----
 
@@ -225,8 +210,10 @@ Optimizers
 
     opt = optim.x(model.parameters(), ...)      # create optimizer
     opt.step()                                  # update weights
-    optim.X                                     # where X is SGD, Adadelta, Adagrad, Adam, 
-                                                # AdamW, SparseAdam, Adamax, ASGD, 
+    opt.zero_grad()                             # clear the gradients
+    optim.X                                     # where X is SGD, AdamW, Adam,
+                                                # Adafactor, NAdam, RAdam, Adadelta,
+                                                # Adagrad, SparseAdam, Adamax, ASGD,
                                                 # LBFGS, RMSprop or Rprop
 
 See `optimizers <https://pytorch.org/docs/stable/optim.html>`__
diff --git a/beginner_source/t5_tutoria.rst b/beginner_source/t5_tutoria.rst
new file mode 100644
index 0000000000..65de42b932
--- /dev/null
+++ b/beginner_source/t5_tutoria.rst
@@ -0,0 +1,10 @@
+T5-Base Model for Summarization, Sentiment Classification, and Translation
+==========================================================================
+
+This tutorial has been deprecated.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/'" />
diff --git a/beginner_source/t5_tutorial.py b/beginner_source/t5_tutorial.py
deleted file mode 100644
index 1387975ad3..0000000000
--- a/beginner_source/t5_tutorial.py
+++ /dev/null
@@ -1,458 +0,0 @@
-"""
-T5-Base Model for Summarization, Sentiment Classification, and Translation
-==========================================================================
-
-**Authors**: `Pendo Abbo <pabbo@fb.com>`__, `Joe Cummings <jrcummings@fb.com>`__
-
-"""
-
-######################################################################
-# Overview
-# --------
-#
-# This tutorial demonstrates how to use a pretrained T5 Model for summarization, sentiment classification, and
-# translation tasks. We will demonstrate how to use the torchtext library to:
-#
-# 1. Build a text preprocessing pipeline for a T5 model
-# 2. Instantiate a pretrained T5 model with base configuration
-# 3. Read in the CNNDM, IMDB, and Multi30k datasets and preprocess their texts in preparation for the model
-# 4. Perform text summarization, sentiment classification, and translation
-#
-# .. note::
-#    This tutorial requires PyTorch 2.0.0 or later.
-#
-#######################################################################
-# Data Transformation
-# -------------------
-#
-# The T5 model does not work with raw text. Instead, it requires the text to be transformed into numerical form
-# in order to perform training and inference. The following transformations are required for the T5 model:
-#
-# 1. Tokenize text
-# 2. Convert tokens into (integer) IDs
-# 3. Truncate the sequences to a specified maximum length
-# 4. Add end-of-sequence (EOS) and padding token IDs
-#
-# T5 uses a ``SentencePiece`` model for text tokenization. Below, we use a pretrained ``SentencePiece`` model to build
-# the text preprocessing pipeline using torchtext's T5Transform. Note that the transform supports both
-# batched and non-batched text input (for example, one can either pass a single sentence or a list of sentences), however the T5 model expects the input to be batched.
-#
-
-from torchtext.models import T5Transform
-
-padding_idx = 0
-eos_idx = 1
-max_seq_len = 512
-t5_sp_model_path = "https://download.pytorch.org/models/text/t5_tokenizer_base.model"
-
-transform = T5Transform(
-    sp_model_path=t5_sp_model_path,
-    max_seq_len=max_seq_len,
-    eos_idx=eos_idx,
-    padding_idx=padding_idx,
-)
-
-#######################################################################
-# Alternatively, we can also use the transform shipped with the pretrained models that does all of the above out-of-the-box
-#
-# .. code-block::
-#
-#   from torchtext.models import T5_BASE_GENERATION
-#   transform = T5_BASE_GENERATION.transform()
-#
-
-
-######################################################################
-# Model Preparation
-# -----------------
-#
-# torchtext provides SOTA pretrained models that can be used directly for NLP tasks or fine-tuned on downstream tasks. Below
-# we use the pretrained T5 model with standard base configuration to perform text summarization, sentiment classification, and
-# translation. For additional details on available pretrained models, see `the torchtext documentation <https://pytorch.org/text/main/models.html>`__
-#
-#
-from torchtext.models import T5_BASE_GENERATION
-
-
-t5_base = T5_BASE_GENERATION
-transform = t5_base.transform()
-model = t5_base.get_model()
-model.eval()
-
-
-#######################################################################
-# Using ``GenerationUtils``
-# -------------------------
-#
-# We can use torchtext's ``GenerationUtils`` to produce an output sequence based on the input sequence provided. This calls on the
-# model's encoder and decoder, and iteratively expands the decoded sequences until the end-of-sequence token is generated
-# for all sequences in the batch. The ``generate`` method shown below uses greedy search to generate the sequences. Beam search and
-# other decoding strategies are also supported.
-#
-#
-from torchtext.prototype.generate import GenerationUtils
-
-sequence_generator = GenerationUtils(model)
-
-
-#######################################################################
-# Datasets
-# --------
-# torchtext provides several standard NLP datasets. For a complete list, refer to the documentation
-# at https://pytorch.org/text/stable/datasets.html. These datasets are built using composable torchdata
-# datapipes and hence support standard flow-control and mapping/transformation using user defined
-# functions and transforms.
-#
-# Below we demonstrate how to preprocess the CNNDM dataset to include the prefix necessary for the
-# model to identify the task it is performing. The CNNDM dataset has a train, validation, and test
-# split. Below we demo on the test split.
-#
-# The T5 model uses the prefix "summarize" for text summarization. For more information on task
-# prefixes, please visit Appendix D of the `T5 Paper <https://arxiv.org/pdf/1910.10683.pdf>`__
-#
-# .. note::
-#       Using datapipes is still currently subject to a few caveats. If you wish
-#       to extend this example to include shuffling, multi-processing, or
-#       distributed learning, please see :ref:`this note <datapipes_warnings>`
-#       for further instructions.
-
-from functools import partial
-
-from torch.utils.data import DataLoader
-from torchtext.datasets import CNNDM
-
-cnndm_batch_size = 5
-cnndm_datapipe = CNNDM(split="test")
-task = "summarize"
-
-
-def apply_prefix(task, x):
-    return f"{task}: " + x[0], x[1]
-
-
-cnndm_datapipe = cnndm_datapipe.map(partial(apply_prefix, task))
-cnndm_datapipe = cnndm_datapipe.batch(cnndm_batch_size)
-cnndm_datapipe = cnndm_datapipe.rows2columnar(["article", "abstract"])
-cnndm_dataloader = DataLoader(cnndm_datapipe, shuffle=True, batch_size=None)
-
-#######################################################################
-# Alternately, we can also use batched API, for example, apply the prefix on the whole batch:
-#
-# .. code-block::
-#
-#   def batch_prefix(task, x):
-#    return {
-#        "article": [f'{task}: ' + y for y in x["article"]],
-#        "abstract": x["abstract"]
-#    }
-#
-#   cnndm_batch_size = 5
-#   cnndm_datapipe = CNNDM(split="test")
-#   task = 'summarize'
-#
-#   cnndm_datapipe = cnndm_datapipe.batch(cnndm_batch_size).rows2columnar(["article", "abstract"])
-#   cnndm_datapipe = cnndm_datapipe.map(partial(batch_prefix, task))
-#   cnndm_dataloader = DataLoader(cnndm_datapipe, batch_size=None)
-#
-
-#######################################################################
-# We can also load the IMDB dataset, which will be used to demonstrate sentiment classification using the T5 model.
-# This dataset has a train and test split. Below we demo on the test split.
-#
-# The T5 model was trained on the SST2 dataset (also available in torchtext) for sentiment classification using the
-# prefix ``sst2 sentence``. Therefore, we will use this prefix to perform sentiment classification on the IMDB dataset.
-#
-
-from torchtext.datasets import IMDB
-
-imdb_batch_size = 3
-imdb_datapipe = IMDB(split="test")
-task = "sst2 sentence"
-labels = {"1": "negative", "2": "positive"}
-
-
-def process_labels(labels, x):
-    return x[1], labels[str(x[0])]
-
-
-imdb_datapipe = imdb_datapipe.map(partial(process_labels, labels))
-imdb_datapipe = imdb_datapipe.map(partial(apply_prefix, task))
-imdb_datapipe = imdb_datapipe.batch(imdb_batch_size)
-imdb_datapipe = imdb_datapipe.rows2columnar(["text", "label"])
-imdb_dataloader = DataLoader(imdb_datapipe, batch_size=None)
-
-#######################################################################
-# Finally, we can also load the Multi30k dataset to demonstrate English to German translation using the T5 model.
-# This dataset has a train, validation, and test split. Below we demo on the test split.
-#
-# The T5 model uses the prefix "translate English to German" for this task.
-
-from torchtext.datasets import Multi30k
-
-multi_batch_size = 5
-language_pair = ("en", "de")
-multi_datapipe = Multi30k(split="test", language_pair=language_pair)
-task = "translate English to German"
-
-multi_datapipe = multi_datapipe.map(partial(apply_prefix, task))
-multi_datapipe = multi_datapipe.batch(multi_batch_size)
-multi_datapipe = multi_datapipe.rows2columnar(["english", "german"])
-multi_dataloader = DataLoader(multi_datapipe, batch_size=None)
-
-#######################################################################
-# Generate Summaries
-# ------------------
-#
-# We can put all of the components together to generate summaries on the first batch of articles in the CNNDM test set
-# using a beam size of 1.
-#
-
-batch = next(iter(cnndm_dataloader))
-input_text = batch["article"]
-target = batch["abstract"]
-beam_size = 1
-
-model_input = transform(input_text)
-model_output = sequence_generator.generate(model_input, eos_idx=eos_idx, num_beams=beam_size)
-output_text = transform.decode(model_output.tolist())
-
-for i in range(cnndm_batch_size):
-    print(f"Example {i+1}:\n")
-    print(f"prediction: {output_text[i]}\n")
-    print(f"target: {target[i]}\n\n")
-
-
-#######################################################################
-# Summarization Output
-# --------------------
-# 
-# Summarization output might vary since we shuffle the dataloader.
-#
-# .. code-block::
-#
-#    Example 1:
-#
-#    prediction: the 24-year-old has been tattooed for over a decade . he has landed in australia
-#    to start work on a new campaign . he says he is 'taking it in your stride' to be honest .
-#
-#    target: London-based model Stephen James Hendry famed for his full body tattoo . The supermodel
-#    is in Sydney for a new modelling campaign . Australian fans understood to have already located
-#    him at his hotel . The 24-year-old heartthrob is recently single .
-#
-#
-#    Example 2:
-#
-#    prediction: a stray pooch has used up at least three of her own after being hit by a
-#    car and buried in a field . the dog managed to stagger to a nearby farm, dirt-covered
-#    and emaciated, where she was found . she suffered a dislocated jaw, leg injuries and a
-#    caved-in sinus cavity -- and still requires surgery to help her breathe .
-#
-#    target: Theia, a bully breed mix, was apparently hit by a car, whacked with a hammer
-#    and buried in a field . "She's a true miracle dog and she deserves a good life," says
-#    Sara Mellado, who is looking for a home for Theia .
-#
-#
-#    Example 3:
-#
-#    prediction: mohammad Javad Zarif arrived in Iran on a sunny friday morning . he has gone
-#    a long way to bring Iran in from the cold and allow it to rejoin the international
-#    community . but there are some facts about him that are less well-known .
-#
-#    target: Mohammad Javad Zarif has spent more time with John Kerry than any other
-#    foreign minister . He once participated in a takeover of the Iranian Consulate in San
-#    Francisco . The Iranian foreign minister tweets in English .
-#
-#
-#    Example 4:
-#
-#    prediction: five americans were monitored for three weeks after being exposed to Ebola in
-#    west africa . one of the five had a heart-related issue and has been discharged but hasn't
-#    left the area . they are clinicians for Partners in Health, a Boston-based aid group .
-#
-#    target: 17 Americans were exposed to the Ebola virus while in Sierra Leone in March .
-#    Another person was diagnosed with the disease and taken to hospital in Maryland .
-#    National Institutes of Health says the patient is in fair condition after weeks of
-#    treatment .
-#
-#
-#    Example 5:
-#
-#    prediction: the student was identified during an investigation by campus police and
-#    the office of student affairs . he admitted to placing the noose on the tree early
-#    Wednesday morning . the incident is one of several recent racist events to affect
-#    college students .
-#
-#    target: Student is no longer on Duke University campus and will face disciplinary
-#    review . School officials identified student during investigation and the person
-#    admitted to hanging the noose, Duke says . The noose, made of rope, was discovered on
-#    campus about 2 a.m.
-#
-
-
-#######################################################################
-# Generate Sentiment Classifications
-# ----------------------------------
-#
-# Similarly, we can use the model to generate sentiment classifications on the first batch of reviews from the IMDB test set
-# using a beam size of 1.
-#
-
-batch = next(iter(imdb_dataloader))
-input_text = batch["text"]
-target = batch["label"]
-beam_size = 1
-
-model_input = transform(input_text)
-model_output = sequence_generator.generate(model_input, eos_idx=eos_idx, num_beams=beam_size)
-output_text = transform.decode(model_output.tolist())
-
-for i in range(imdb_batch_size):
-    print(f"Example {i+1}:\n")
-    print(f"input_text: {input_text[i]}\n")
-    print(f"prediction: {output_text[i]}\n")
-    print(f"target: {target[i]}\n\n")
-
-
-#######################################################################
-# Sentiment Output
-# ----------------
-#
-# .. code-block:: bash
-#
-#    Example 1:
-#
-#    input_text: sst2 sentence: I love sci-fi and am willing to put up with a lot. Sci-fi
-#    movies/TV are usually underfunded, under-appreciated and misunderstood. I tried to like
-#    this, I really did, but it is to good TV sci-fi as Babylon 5 is to Star Trek (the original).
-#    Silly prosthetics, cheap cardboard sets, stilted dialogues, CG that doesn't match the
-#    background, and painfully one-dimensional characters cannot be overcome with a 'sci-fi'
-#    setting. (I'm sure there are those of you out there who think Babylon 5 is good sci-fi TV.
-#    It's not. It's clichéd and uninspiring.) While US viewers might like emotion and character
-#    development, sci-fi is a genre that does not take itself seriously (cf. Star Trek). It may
-#    treat important issues, yet not as a serious philosophy. It's really difficult to care about
-#    the characters here as they are not simply foolish, just missing a spark of life. Their
-#    actions and reactions are wooden and predictable, often painful to watch. The makers of Earth
-#    KNOW it's rubbish as they have to always say "Gene Roddenberry's Earth..." otherwise people
-#    would not continue watching. Roddenberry's ashes must be turning in their orbit as this dull,
-#    cheap, poorly edited (watching it without advert breaks really brings this home) trudging
-#    Trabant of a show lumbers into space. Spoiler. So, kill off a main character. And then bring
-#    him back as another actor. Jeeez. Dallas all over again.
-#
-#    prediction: negative
-#
-#    target: negative
-#
-#
-#    Example 2:
-#
-#    input_text: sst2 sentence: Worth the entertainment value of a rental, especially if you like
-#    action movies. This one features the usual car chases, fights with the great Van Damme kick
-#    style, shooting battles with the 40 shell load shotgun, and even terrorist style bombs. All
-#    of this is entertaining and competently handled but there is nothing that really blows you
-#    away if you've seen your share before.<br /><br />The plot is made interesting by the
-#    inclusion of a rabbit, which is clever but hardly profound. Many of the characters are
-#    heavily stereotyped -- the angry veterans, the terrified illegal aliens, the crooked cops,
-#    the indifferent feds, the bitchy tough lady station head, the crooked politician, the fat
-#    federale who looks like he was typecast as the Mexican in a Hollywood movie from the 1940s.
-#    All passably acted but again nothing special.<br /><br />I thought the main villains were
-#    pretty well done and fairly well acted. By the end of the movie you certainly knew who the
-#    good guys were and weren't. There was an emotional lift as the really bad ones got their just
-#    deserts. Very simplistic, but then you weren't expecting Hamlet, right? The only thing I found
-#    really annoying was the constant cuts to VDs daughter during the last fight scene.<br /><br />
-#    Not bad. Not good. Passable 4.
-#
-#    prediction: positive
-#
-#    target: negative
-#
-#
-#    Example 3:
-#
-#    input_text: sst2 sentence: its a totally average film with a few semi-alright action sequences
-#    that make the plot seem a little better and remind the viewer of the classic van dam films.
-#    parts of the plot don't make sense and seem to be added in to use up time. the end plot is that
-#    of a very basic type that doesn't leave the viewer guessing and any twists are obvious from the
-#    beginning. the end scene with the flask backs don't make sense as they are added in and seem to
-#    have little relevance to the history of van dam's character. not really worth watching again,
-#    bit disappointed in the end production, even though it is apparent it was shot on a low budget
-#    certain shots and sections in the film are of poor directed quality.
-#
-#    prediction: negative
-#
-#    target: negative
-#
-
-
-#######################################################################
-# Generate Translations
-# ---------------------
-#
-# Finally, we can also use the model to generate English to German translations on the first batch of examples from the Multi30k
-# test set.
-#
-
-batch = next(iter(multi_dataloader))
-input_text = batch["english"]
-target = batch["german"]
-
-model_input = transform(input_text)
-model_output = sequence_generator.generate(model_input, eos_idx=eos_idx, num_beams=beam_size)
-output_text = transform.decode(model_output.tolist())
-
-for i in range(multi_batch_size):
-    print(f"Example {i+1}:\n")
-    print(f"input_text: {input_text[i]}\n")
-    print(f"prediction: {output_text[i]}\n")
-    print(f"target: {target[i]}\n\n")
-
-
-#######################################################################
-# Translation Output
-# ------------------
-#
-# .. code-block:: bash
-#
-#    Example 1:
-#
-#    input_text: translate English to German: A man in an orange hat starring at something.
-#
-#    prediction: Ein Mann in einem orangen Hut, der an etwas schaut.
-#
-#    target: Ein Mann mit einem orangefarbenen Hut, der etwas anstarrt.
-#
-#
-#    Example 2:
-#
-#    input_text: translate English to German: A Boston Terrier is running on lush green grass in front of a white fence.
-#
-#    prediction: Ein Boston Terrier läuft auf üppigem grünem Gras vor einem weißen Zaun.
-#
-#    target: Ein Boston Terrier läuft über saftig-grünes Gras vor einem weißen Zaun.
-#
-#
-#    Example 3:
-#
-#    input_text: translate English to German: A girl in karate uniform breaking a stick with a front kick.
-#
-#    prediction: Ein Mädchen in Karate-Uniform bricht einen Stöck mit einem Frontkick.
-#
-#    target: Ein Mädchen in einem Karateanzug bricht ein Brett mit einem Tritt.
-#
-#
-#    Example 4:
-#
-#    input_text: translate English to German: Five people wearing winter jackets and helmets stand in the snow, with snowmobiles in the background.
-#
-#    prediction: Fünf Menschen mit Winterjacken und Helmen stehen im Schnee, mit Schneemobilen im Hintergrund.
-#
-#    target: Fünf Leute in Winterjacken und mit Helmen stehen im Schnee mit Schneemobilen im Hintergrund.
-#
-#
-#    Example 5:
-#
-#    input_text: translate English to German: People are fixing the roof of a house.
-#
-#    prediction: Die Leute fixieren das Dach eines Hauses.
-#
-#    target: Leute Reparieren das Dach eines Hauses.
-#
diff --git a/beginner_source/text_sentiment_ngrams_tutorial.py b/beginner_source/text_sentiment_ngrams_tutorial.py
deleted file mode 100644
index 9cc5d6c867..0000000000
--- a/beginner_source/text_sentiment_ngrams_tutorial.py
+++ /dev/null
@@ -1,372 +0,0 @@
-"""
-Text classification with the torchtext library
-==============================================
-
-In this tutorial, we will show how to use the torchtext library to build the dataset for the text classification analysis. Users will have the flexibility to
-
-   - Access to the raw data as an iterator
-   - Build data processing pipeline to convert the raw text strings into ``torch.Tensor`` that can be used to train the model
-   - Shuffle and iterate the data with `torch.utils.data.DataLoader <https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader>`__
-
-
-Prerequisites
-~~~~~~~~~~~~~~~~
-
-A recent 2.x version of the ``portalocker`` package needs to be installed prior to running the tutorial.
-For example, in the Colab environment, this can be done by adding the following line at the top of the script:
-
-.. code-block:: bash 
-     
-    !pip install -U portalocker>=2.0.0`
-
-"""
-
-
-######################################################################
-# Access to the raw dataset iterators
-# -----------------------------------
-#
-# The torchtext library provides a few raw dataset iterators, which yield the raw text strings. For example, the ``AG_NEWS`` dataset iterators yield the raw data as a tuple of label and text.
-#
-# To access torchtext datasets, please install torchdata following instructions at https://github.com/pytorch/data.
-#
-
-import torch
-from torchtext.datasets import AG_NEWS
-
-train_iter = iter(AG_NEWS(split="train"))
-
-######################################################################
-# .. code-block:: sh
-#
-#     next(train_iter)
-#     >>> (3, "Fears for T N pension after talks Unions representing workers at Turner
-#     Newall say they are 'disappointed' after talks with stricken parent firm Federal
-#     Mogul.")
-#
-#     next(train_iter)
-#     >>> (4, "The Race is On: Second Private Team Sets Launch Date for Human
-#     Spaceflight (SPACE.com) SPACE.com - TORONTO, Canada -- A second\\team of
-#     rocketeers competing for the  #36;10 million Ansari X Prize, a contest
-#     for\\privately funded suborbital space flight, has officially announced
-#     the first\\launch date for its manned rocket.")
-#
-#     next(train_iter)
-#     >>> (4, 'Ky. Company Wins Grant to Study Peptides (AP) AP - A company founded
-#     by a chemistry researcher at the University of Louisville won a grant to develop
-#     a method of producing better peptides, which are short chains of amino acids, the
-#     building blocks of proteins.')
-#
-
-
-######################################################################
-# Prepare data processing pipelines
-# ---------------------------------
-#
-# We have revisited the very basic components of the torchtext library, including vocab, word vectors, tokenizer. Those are the basic data processing building blocks for raw text string.
-#
-# Here is an example for typical NLP data processing with tokenizer and vocabulary. The first step is to build a vocabulary with the raw training dataset. Here we use built in
-# factory function `build_vocab_from_iterator` which accepts iterator that yield list or iterator of tokens. Users can also pass any special symbols to be added to the
-# vocabulary.
-
-
-from torchtext.data.utils import get_tokenizer
-from torchtext.vocab import build_vocab_from_iterator
-
-tokenizer = get_tokenizer("basic_english")
-train_iter = AG_NEWS(split="train")
-
-
-def yield_tokens(data_iter):
-    for _, text in data_iter:
-        yield tokenizer(text)
-
-
-vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=["<unk>"])
-vocab.set_default_index(vocab["<unk>"])
-
-######################################################################
-# The vocabulary block converts a list of tokens into integers.
-#
-# .. code-block:: sh
-#
-#     vocab(['here', 'is', 'an', 'example'])
-#     >>> [475, 21, 30, 5297]
-#
-# Prepare the text processing pipeline with the tokenizer and vocabulary. The text and label pipelines will be used to process the raw data strings from the dataset iterators.
-
-text_pipeline = lambda x: vocab(tokenizer(x))
-label_pipeline = lambda x: int(x) - 1
-
-
-######################################################################
-# The text pipeline converts a text string into a list of integers based on the lookup table defined in the vocabulary. The label pipeline converts the label into integers. For example,
-#
-# .. code-block:: sh
-#
-#     text_pipeline('here is the an example')
-#     >>> [475, 21, 2, 30, 5297]
-#     label_pipeline('10')
-#     >>> 9
-#
-
-
-######################################################################
-# Generate data batch and iterator
-# --------------------------------
-#
-# `torch.utils.data.DataLoader <https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader>`__
-# is recommended for PyTorch users (a tutorial is `here <https://pytorch.org/tutorials/beginner/data_loading_tutorial.html>`__).
-# It works with a map-style dataset that implements the ``getitem()`` and ``len()`` protocols, and represents a map from indices/keys to data samples. It also works with an iterable dataset with the shuffle argument of ``False``.
-#
-# Before sending to the model, ``collate_fn`` function works on a batch of samples generated from ``DataLoader``. The input to ``collate_fn`` is a batch of data with the batch size in ``DataLoader``, and ``collate_fn`` processes them according to the data processing pipelines declared previously. Pay attention here and make sure that ``collate_fn`` is declared as a top level def. This ensures that the function is available in each worker.
-#
-# In this example, the text entries in the original data batch input are packed into a list and concatenated as a single tensor for the input of ``nn.EmbeddingBag``. The offset is a tensor of delimiters to represent the beginning index of the individual sequence in the text tensor. Label is a tensor saving the labels of individual text entries.
-
-
-from torch.utils.data import DataLoader
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-
-def collate_batch(batch):
-    label_list, text_list, offsets = [], [], [0]
-    for _label, _text in batch:
-        label_list.append(label_pipeline(_label))
-        processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
-        text_list.append(processed_text)
-        offsets.append(processed_text.size(0))
-    label_list = torch.tensor(label_list, dtype=torch.int64)
-    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
-    text_list = torch.cat(text_list)
-    return label_list.to(device), text_list.to(device), offsets.to(device)
-
-
-train_iter = AG_NEWS(split="train")
-dataloader = DataLoader(
-    train_iter, batch_size=8, shuffle=False, collate_fn=collate_batch
-)
-
-
-######################################################################
-# Define the model
-# ----------------
-#
-# The model is composed of the `nn.EmbeddingBag <https://pytorch.org/docs/stable/nn.html?highlight=embeddingbag#torch.nn.EmbeddingBag>`__ layer plus a linear layer for the classification purpose. ``nn.EmbeddingBag`` with the default mode of "mean" computes the mean value of a “bag” of embeddings. Although the text entries here have different lengths, ``nn.EmbeddingBag`` module requires no padding here since the text lengths are saved in offsets.
-#
-# Additionally, since ``nn.EmbeddingBag`` accumulates the average across
-# the embeddings on the fly, ``nn.EmbeddingBag`` can enhance the
-# performance and memory efficiency to process a sequence of tensors.
-#
-# .. image:: ../_static/img/text_sentiment_ngrams_model.png
-#
-
-from torch import nn
-
-
-class TextClassificationModel(nn.Module):
-    def __init__(self, vocab_size, embed_dim, num_class):
-        super(TextClassificationModel, self).__init__()
-        self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=False)
-        self.fc = nn.Linear(embed_dim, num_class)
-        self.init_weights()
-
-    def init_weights(self):
-        initrange = 0.5
-        self.embedding.weight.data.uniform_(-initrange, initrange)
-        self.fc.weight.data.uniform_(-initrange, initrange)
-        self.fc.bias.data.zero_()
-
-    def forward(self, text, offsets):
-        embedded = self.embedding(text, offsets)
-        return self.fc(embedded)
-
-
-######################################################################
-# Initiate an instance
-# --------------------
-#
-# The ``AG_NEWS`` dataset has four labels and therefore the number of classes is four.
-#
-# .. code-block:: sh
-#
-#    1 : World
-#    2 : Sports
-#    3 : Business
-#    4 : Sci/Tec
-#
-# We build a model with the embedding dimension of 64. The vocab size is equal to the length of the vocabulary instance. The number of classes is equal to the number of labels,
-#
-
-train_iter = AG_NEWS(split="train")
-num_class = len(set([label for (label, text) in train_iter]))
-vocab_size = len(vocab)
-emsize = 64
-model = TextClassificationModel(vocab_size, emsize, num_class).to(device)
-
-
-######################################################################
-# Define functions to train the model and evaluate results.
-# ---------------------------------------------------------
-#
-
-
-import time
-
-
-def train(dataloader):
-    model.train()
-    total_acc, total_count = 0, 0
-    log_interval = 500
-    start_time = time.time()
-
-    for idx, (label, text, offsets) in enumerate(dataloader):
-        optimizer.zero_grad()
-        predicted_label = model(text, offsets)
-        loss = criterion(predicted_label, label)
-        loss.backward()
-        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1)
-        optimizer.step()
-        total_acc += (predicted_label.argmax(1) == label).sum().item()
-        total_count += label.size(0)
-        if idx % log_interval == 0 and idx > 0:
-            elapsed = time.time() - start_time
-            print(
-                "| epoch {:3d} | {:5d}/{:5d} batches "
-                "| accuracy {:8.3f}".format(
-                    epoch, idx, len(dataloader), total_acc / total_count
-                )
-            )
-            total_acc, total_count = 0, 0
-            start_time = time.time()
-
-
-def evaluate(dataloader):
-    model.eval()
-    total_acc, total_count = 0, 0
-
-    with torch.no_grad():
-        for idx, (label, text, offsets) in enumerate(dataloader):
-            predicted_label = model(text, offsets)
-            loss = criterion(predicted_label, label)
-            total_acc += (predicted_label.argmax(1) == label).sum().item()
-            total_count += label.size(0)
-    return total_acc / total_count
-
-
-######################################################################
-# Split the dataset and run the model
-# -----------------------------------
-#
-# Since the original ``AG_NEWS`` has no valid dataset, we split the training
-# dataset into train/valid sets with a split ratio of 0.95 (train) and
-# 0.05 (valid). Here we use
-# `torch.utils.data.dataset.random_split <https://pytorch.org/docs/stable/data.html?highlight=random_split#torch.utils.data.random_split>`__
-# function in PyTorch core library.
-#
-# `CrossEntropyLoss <https://pytorch.org/docs/stable/nn.html?highlight=crossentropyloss#torch.nn.CrossEntropyLoss>`__
-# criterion combines ``nn.LogSoftmax()`` and ``nn.NLLLoss()`` in a single class.
-# It is useful when training a classification problem with C classes.
-# `SGD <https://pytorch.org/docs/stable/_modules/torch/optim/sgd.html>`__
-# implements stochastic gradient descent method as the optimizer. The initial
-# learning rate is set to 5.0.
-# `StepLR <https://pytorch.org/docs/master/_modules/torch/optim/lr_scheduler.html#StepLR>`__
-# is used here to adjust the learning rate through epochs.
-#
-
-
-from torch.utils.data.dataset import random_split
-from torchtext.data.functional import to_map_style_dataset
-
-# Hyperparameters
-EPOCHS = 10  # epoch
-LR = 5  # learning rate
-BATCH_SIZE = 64  # batch size for training
-
-criterion = torch.nn.CrossEntropyLoss()
-optimizer = torch.optim.SGD(model.parameters(), lr=LR)
-scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1.0, gamma=0.1)
-total_accu = None
-train_iter, test_iter = AG_NEWS()
-train_dataset = to_map_style_dataset(train_iter)
-test_dataset = to_map_style_dataset(test_iter)
-num_train = int(len(train_dataset) * 0.95)
-split_train_, split_valid_ = random_split(
-    train_dataset, [num_train, len(train_dataset) - num_train]
-)
-
-train_dataloader = DataLoader(
-    split_train_, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch
-)
-valid_dataloader = DataLoader(
-    split_valid_, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch
-)
-test_dataloader = DataLoader(
-    test_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch
-)
-
-for epoch in range(1, EPOCHS + 1):
-    epoch_start_time = time.time()
-    train(train_dataloader)
-    accu_val = evaluate(valid_dataloader)
-    if total_accu is not None and total_accu > accu_val:
-        scheduler.step()
-    else:
-        total_accu = accu_val
-    print("-" * 59)
-    print(
-        "| end of epoch {:3d} | time: {:5.2f}s | "
-        "valid accuracy {:8.3f} ".format(
-            epoch, time.time() - epoch_start_time, accu_val
-        )
-    )
-    print("-" * 59)
-
-
-######################################################################
-# Evaluate the model with test dataset
-# ------------------------------------
-#
-
-
-######################################################################
-# Checking the results of the test dataset…
-
-print("Checking the results of test dataset.")
-accu_test = evaluate(test_dataloader)
-print("test accuracy {:8.3f}".format(accu_test))
-
-
-######################################################################
-# Test on a random news
-# ---------------------
-#
-# Use the best model so far and test a golf news.
-#
-
-
-ag_news_label = {1: "World", 2: "Sports", 3: "Business", 4: "Sci/Tec"}
-
-
-def predict(text, text_pipeline):
-    with torch.no_grad():
-        text = torch.tensor(text_pipeline(text))
-        output = model(text, torch.tensor([0]))
-        return output.argmax(1).item() + 1
-
-
-ex_text_str = "MEMPHIS, Tenn. – Four days ago, Jon Rahm was \
-    enduring the season’s worst weather conditions on Sunday at The \
-    Open on his way to a closing 75 at Royal Portrush, which \
-    considering the wind and the rain was a respectable showing. \
-    Thursday’s first round at the WGC-FedEx St. Jude Invitational \
-    was another story. With temperatures in the mid-80s and hardly any \
-    wind, the Spaniard was 13 strokes better in a flawless round. \
-    Thanks to his best putting performance on the PGA Tour, Rahm \
-    finished with an 8-under 62 for a three-stroke lead, which \
-    was even more impressive considering he’d never played the \
-    front nine at TPC Southwind."
-
-model = model.to("cpu")
-
-print("This is a %s news" % ag_news_label[predict(ex_text_str, text_pipeline)])
diff --git a/beginner_source/text_sentiment_ngrams_tutorial.rst b/beginner_source/text_sentiment_ngrams_tutorial.rst
new file mode 100644
index 0000000000..024d04056c
--- /dev/null
+++ b/beginner_source/text_sentiment_ngrams_tutorial.rst
@@ -0,0 +1,12 @@
+:orphan:
+
+Text classification with the torchtext library
+==============================================
+
+This tutorial has been deprecated.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials'" />
diff --git a/beginner_source/torchtext_custom_dataset_tutorial.py b/beginner_source/torchtext_custom_dataset_tutorial.py
deleted file mode 100644
index 9875d8aa43..0000000000
--- a/beginner_source/torchtext_custom_dataset_tutorial.py
+++ /dev/null
@@ -1,384 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Preprocess custom text dataset using Torchtext
-===============================================
-
-**Author**: `Anupam Sharma <https://anp-scp.github.io/>`_
-
-This tutorial illustrates the usage of torchtext on a dataset that is not built-in. In the tutorial,
-we will preprocess a dataset that can be further utilized to train a sequence-to-sequence
-model for machine translation (something like, in this tutorial: `Sequence to Sequence Learning
-with Neural Networks <https://github.com/bentrevett/pytorch-seq2seq/blob/master/1%20-%20Sequence%\
-20to%20Sequence%20Learning%20with%20Neural%20Networks.ipynb>`_) but without using legacy version
-of torchtext.
-
-In this tutorial, we will learn how to:
-
-* Read a dataset
-* Tokenize sentence
-* Apply transforms to sentence
-* Perform bucket batching
-
-Let us assume that we need to prepare a dataset to train a model that can perform English to
-German translation. We will use a tab-delimited German - English sentence pairs provided by
-the `Tatoeba Project <https://tatoeba.org/en>`_ which can be downloaded from
-`this link <https://www.manythings.org/anki/deu-eng.zip>`__.
-
-Sentence pairs for other languages can be found in `this link <https://www.manythings.org/anki/>`\
-__.
-"""
-
-# %%
-# Setup
-# -----
-#
-# First, download the dataset, extract the zip, and note the path to the file `deu.txt`.
-#
-# Ensure that following packages are installed:
-#
-# * `Torchdata 0.6.0 <https://pytorch.org/data/beta/index.html>`_ (`Installation instructions \
-#   <https://github.com/pytorch/data>`__)
-# * `Torchtext 0.15.0 <https://pytorch.org/text/stable/index.html>`_ (`Installation instructions \
-#   <https://github.com/pytorch/text>`__)
-# * `Spacy <https://spacy.io/usage>`__
-#
-# Here, we are using `Spacy` to tokenize text. In simple words tokenization means to
-# convert a sentence to list of words. Spacy is a python package used for various Natural
-# Language Processing (NLP) tasks.
-#
-# Download the English and German models from Spacy as shown below:
-#
-# .. code-block:: shell
-#
-#    python -m spacy download en_core_web_sm
-#    python -m spacy download de_core_news_sm
-#
-
-
-# %%
-# Let us start by importing required modules:
-
-import torchdata.datapipes as dp
-import torchtext.transforms as T
-import spacy
-from torchtext.vocab import build_vocab_from_iterator
-eng = spacy.load("en_core_web_sm") # Load the English model to tokenize English text
-de = spacy.load("de_core_news_sm") # Load the German model to tokenize German text
-
-# %%
-# Now we will load the dataset
-
-FILE_PATH = 'data/deu.txt'
-data_pipe = dp.iter.IterableWrapper([FILE_PATH])
-data_pipe = dp.iter.FileOpener(data_pipe, mode='rb')
-data_pipe = data_pipe.parse_csv(skip_lines=0, delimiter='\t', as_tuple=True)
-
-# %%
-# In the above code block, we are doing following things:
-#
-# 1. At line 2, we are creating an iterable of filenames
-# 2. At line 3, we pass the iterable to `FileOpener` which then
-#    opens the file in read mode
-# 3. At line 4, we call a function to parse the file, which
-#    again returns an iterable of tuples representing each rows
-#    of the tab-delimited file
-#
-# DataPipes can be thought of something like a dataset object, on which
-# we can perform various operations.
-# Check `this tutorial <https://pytorch.org/data/beta/dp_tutorial.html>`_ for more details on
-# DataPipes.
-#
-# We can verify if the iterable has the pair of sentences as shown
-# below:
-
-for sample in data_pipe:
-    print(sample)
-    break
-
-# %%
-# Note that we also have attribution details along with pair of sentences. We will
-# write a small function to remove the attribution details:
-
-def removeAttribution(row):
-    """
-    Function to keep the first two elements in a tuple
-    """
-    return row[:2]
-data_pipe = data_pipe.map(removeAttribution)
-
-# %%
-# The `map` function at line 6 in above code block can be used to apply some function
-# on each elements of `data_pipe`. Now, we can verify that the `data_pipe` only contains
-# pair of sentences.
-
-
-for sample in data_pipe:
-    print(sample)
-    break
-
-# %%
-# Now, let us define few functions to perform tokenization:
-
-def engTokenize(text):
-    """
-    Tokenize an English text and return a list of tokens
-    """
-    return [token.text for token in eng.tokenizer(text)]
-
-def deTokenize(text):
-    """
-    Tokenize a German text and return a list of tokens
-    """
-    return [token.text for token in de.tokenizer(text)]
-
-# %%
-# Above function accepts a text and returns a list of words
-# as shown below:
-
-print(engTokenize("Have a good day!!!"))
-print(deTokenize("Haben Sie einen guten Tag!!!"))
-
-# %%
-# Building the vocabulary
-# -----------------------
-# Let us consider an English sentence as the source and a German sentence as the target.
-#
-# Vocabulary can be considered as the set of unique words we have in the dataset.
-# We will build vocabulary for both our source and target now.
-#
-# Let us define a function to get tokens from elements of tuples in the iterator.
-
-
-def getTokens(data_iter, place):
-    """
-    Function to yield tokens from an iterator. Since, our iterator contains
-    tuple of sentences (source and target), `place` parameters defines for which
-    index to return the tokens for. `place=0` for source and `place=1` for target
-    """
-    for english, german in data_iter:
-        if place == 0:
-            yield engTokenize(english)
-        else:
-            yield deTokenize(german)
-
-# %%
-# Now, we will build vocabulary for source:
-
-source_vocab = build_vocab_from_iterator(
-    getTokens(data_pipe,0),
-    min_freq=2,
-    specials= ['<pad>', '<sos>', '<eos>', '<unk>'],
-    special_first=True
-)
-source_vocab.set_default_index(source_vocab['<unk>'])
-
-# %%
-# The code above, builds the vocabulary from the iterator. In the above code block:
-#
-# * At line 2, we call the `getTokens()` function with `place=0` as we need vocabulary for
-#   source sentences.
-# * At line 3, we set `min_freq=2`. This means, the function will skip those words that occurs
-#   less than 2 times.
-# * At line 4, we specify some special tokens:
-#
-#   * `<sos>` for start of sentence
-#   * `<eos>` for end of sentence
-#   * `<unk>` for unknown words. An example of unknown word is the one skipped because of
-#     `min_freq=2`.
-#   * `<pad>` is the padding token. While training, a model we mostly train in batches. In a
-#     batch, there can be sentences of different length. So, we pad the shorter sentences with
-#     `<pad>` token to make length of all sequences in the batch equal.
-#
-# * At line 5, we set `special_first=True`. Which means `<pad>` will get index 0, `<sos>` index 1,
-#   `<eos>` index 2, and <unk> will get index 3 in the vocabulary.
-# * At line 7, we set default index as index of `<unk>`. That means if some word is not in
-#   vocabulary, we will use `<unk>` instead of that unknown word.
-#
-# Similarly, we will build vocabulary for target sentences:
-
-target_vocab = build_vocab_from_iterator(
-    getTokens(data_pipe,1),
-    min_freq=2,
-    specials= ['<pad>', '<sos>', '<eos>', '<unk>'],
-    special_first=True
-)
-target_vocab.set_default_index(target_vocab['<unk>'])
-
-# %%
-# Note that the example above shows how can we add special tokens to our vocabulary. The
-# special tokens may change based on the requirements.
-#
-# Now, we can verify that special tokens are placed at the beginning and then other words.
-# In the below code, `source_vocab.get_itos()` returns a list with tokens at index based on
-# vocabulary.
-
-print(source_vocab.get_itos()[:9])
-
-# %%
-# Numericalize sentences using vocabulary
-# ---------------------------------------
-# After building the vocabulary, we need to convert our sentences to corresponding indices.
-# Let us define some functions for this:
-
-def getTransform(vocab):
-    """
-    Create transforms based on given vocabulary. The returned transform is applied to sequence
-    of tokens.
-    """
-    text_tranform = T.Sequential(
-        ## converts the sentences to indices based on given vocabulary
-        T.VocabTransform(vocab=vocab),
-        ## Add <sos> at beginning of each sentence. 1 because the index for <sos> in vocabulary is
-        # 1 as seen in previous section
-        T.AddToken(1, begin=True),
-        ## Add <eos> at beginning of each sentence. 2 because the index for <eos> in vocabulary is
-        # 2 as seen in previous section
-        T.AddToken(2, begin=False)
-    )
-    return text_tranform
-
-# %%
-# Now, let us see how to use the above function. The function returns an object of `Transforms`
-# which we will use on our sentence. Let us take a random sentence and check how the transform
-# works.
-
-temp_list = list(data_pipe)
-some_sentence = temp_list[798][0]
-print("Some sentence=", end="")
-print(some_sentence)
-transformed_sentence = getTransform(source_vocab)(engTokenize(some_sentence))
-print("Transformed sentence=", end="")
-print(transformed_sentence)
-index_to_string = source_vocab.get_itos()
-for index in transformed_sentence:
-    print(index_to_string[index], end=" ")
-
-# %%
-# In the above code,:
-#
-# * At line 2, we take a source sentence from list that we created from `data_pipe` at line 1
-# * At line 5, we get a transform based on a source vocabulary and apply it to a tokenized
-#   sentence. Note that transforms take list of words and not a sentence.
-# * At line 8, we get the mapping of index to string and then use it get the transformed
-#   sentence
-#
-# Now we will use DataPipe functions to apply transform to all our sentences.
-# Let us define some more functions for this.
-
-def applyTransform(sequence_pair):
-    """
-    Apply transforms to sequence of tokens in a sequence pair
-    """
-
-    return (
-        getTransform(source_vocab)(engTokenize(sequence_pair[0])),
-        getTransform(target_vocab)(deTokenize(sequence_pair[1]))
-    )
-data_pipe = data_pipe.map(applyTransform) ## Apply the function to each element in the iterator
-temp_list = list(data_pipe)
-print(temp_list[0])
-
-# %%
-# Make batches (with bucket batch)
-# --------------------------------
-# Generally, we train models in batches. While working for sequence to sequence models, it is
-# recommended to keep the length of sequences in a batch similar. For that we will use
-# `bucketbatch` function of `data_pipe`.
-#
-# Let us define some functions that will be used by the `bucketbatch` function.
-
-def sortBucket(bucket):
-    """
-    Function to sort a given bucket. Here, we want to sort based on the length of
-    source and target sequence.
-    """
-    return sorted(bucket, key=lambda x: (len(x[0]), len(x[1])))
-
-# %%
-# Now, we will apply the `bucketbatch` function:
-
-data_pipe = data_pipe.bucketbatch(
-    batch_size = 4, batch_num=5,  bucket_num=1,
-    use_in_batch_shuffle=False, sort_key=sortBucket
-)
-
-# %%
-# In the above code block:
-#
-#   * We keep batch size = 4.
-#   * `batch_num` is the number of batches to keep in a bucket
-#   * `bucket_num` is the number of buckets to keep in a pool for shuffling
-#   * `sort_key` specifies the function that takes a bucket and sorts it
-#
-# Now, let us consider a batch of source sentences as `X` and a batch of target sentences as `y`.
-# Generally, while training a model, we predict on a batch of `X` and compare the result with `y`.
-# But, a batch in our `data_pipe` is of the form `[(X_1,y_1), (X_2,y_2), (X_3,y_3), (X_4,y_4)]`:
-
-print(list(data_pipe)[0])
-# %%
-# So, we will now convert them into the form: `((X_1,X_2,X_3,X_4), (y_1,y_2,y_3,y_4))`.
-# For this we will write a small function:
-
-def separateSourceTarget(sequence_pairs):
-    """
-    input of form: `[(X_1,y_1), (X_2,y_2), (X_3,y_3), (X_4,y_4)]`
-    output of form: `((X_1,X_2,X_3,X_4), (y_1,y_2,y_3,y_4))`
-    """
-    sources,targets = zip(*sequence_pairs)
-    return sources,targets
-
-## Apply the function to each element in the iterator
-data_pipe = data_pipe.map(separateSourceTarget)
-print(list(data_pipe)[0])
-
-# %%
-# Now, we have the data as desired.
-#
-# Padding
-# -------
-# As discussed earlier while building vocabulary, we need to pad shorter sentences in a batch to
-# make all the sequences in a batch of equal length. We can perform padding as follows:
-
-def applyPadding(pair_of_sequences):
-    """
-    Convert sequences to tensors and apply padding
-    """
-    return (T.ToTensor(0)(list(pair_of_sequences[0])), T.ToTensor(0)(list(pair_of_sequences[1])))
-## `T.ToTensor(0)` returns a transform that converts the sequence to `torch.tensor` and also applies
-# padding. Here, `0` is passed to the constructor to specify the index of the `<pad>` token in the
-# vocabulary.
-data_pipe = data_pipe.map(applyPadding)
-
-# %%
-# Now, we can use the index to string mapping to see how the sequence would look with tokens
-# instead of indices:
-
-source_index_to_string = source_vocab.get_itos()
-target_index_to_string = target_vocab.get_itos()
-
-def showSomeTransformedSentences(data_pipe):
-    """
-    Function to show how the sentences look like after applying all transforms.
-    Here we try to print actual words instead of corresponding index
-    """
-    for sources,targets in data_pipe:
-        if sources[0][-1] != 0:
-            continue # Just to visualize padding of shorter sentences
-        for i in range(4):
-            source = ""
-            for token in sources[i]:
-                source += " " + source_index_to_string[token]
-            target = ""
-            for token in targets[i]:
-                target += " " + target_index_to_string[token]
-            print(f"Source: {source}")
-            print(f"Traget: {target}")
-        break
-
-showSomeTransformedSentences(data_pipe)
-# %%
-# In the above output we can observe that the shorter sentences are padded with `<pad>`. Now, we
-# can use `data_pipe` while writing our training function.
-#
-# Some parts of this tutorial was inspired from `this article
-# <https://medium.com/@bitdribble/migrate-torchtext-to-the-new-0-9-0-api-1ff1472b5d71>`__.
diff --git a/beginner_source/torchtext_custom_dataset_tutorial.rst b/beginner_source/torchtext_custom_dataset_tutorial.rst
new file mode 100644
index 0000000000..9f014f3ff9
--- /dev/null
+++ b/beginner_source/torchtext_custom_dataset_tutorial.rst
@@ -0,0 +1,12 @@
+:orphan:
+
+Preprocess custom text dataset using torchtext
+==============================================
+
+This tutorial has been deprecated.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials'" />
diff --git a/beginner_source/translation_transformer.py b/beginner_source/translation_transformer.py
deleted file mode 100644
index c5553246e3..0000000000
--- a/beginner_source/translation_transformer.py
+++ /dev/null
@@ -1,404 +0,0 @@
-"""
-Language Translation with ``nn.Transformer`` and torchtext
-==========================================================
-
-This tutorial shows:
-    - How to train a translation model from scratch using Transformer.
-    - Use torchtext library to access  `Multi30k <http://www.statmt.org/wmt16/multimodal-task.html#task1>`__ dataset to train a German to English translation model.
-"""
-
-
-######################################################################
-# Data Sourcing and Processing
-# ----------------------------
-#
-# `torchtext library <https://pytorch.org/text/stable/>`__ has utilities for creating datasets that can be easily
-# iterated through for the purposes of creating a language translation
-# model. In this example, we show how to use torchtext's inbuilt datasets,
-# tokenize a raw text sentence, build vocabulary, and numericalize tokens into tensor. We will use
-# `Multi30k dataset from torchtext library <https://pytorch.org/text/stable/datasets.html#multi30k>`__
-# that yields a pair of source-target raw sentences.
-#
-# To access torchtext datasets, please install torchdata following instructions at https://github.com/pytorch/data.
-#
-
-from torchtext.data.utils import get_tokenizer
-from torchtext.vocab import build_vocab_from_iterator
-from torchtext.datasets import multi30k, Multi30k
-from typing import Iterable, List
-
-
-# We need to modify the URLs for the dataset since the links to the original dataset are broken
-# Refer to https://github.com/pytorch/text/issues/1756#issuecomment-1163664163 for more info
-multi30k.URL["train"] = "https://raw.githubusercontent.com/neychev/small_DL_repo/master/datasets/Multi30k/training.tar.gz"
-multi30k.URL["valid"] = "https://raw.githubusercontent.com/neychev/small_DL_repo/master/datasets/Multi30k/validation.tar.gz"
-
-SRC_LANGUAGE = 'de'
-TGT_LANGUAGE = 'en'
-
-# Place-holders
-token_transform = {}
-vocab_transform = {}
-
-###################################################################################
-# Create source and target language tokenizer. Make sure to install the dependencies.
-#
-# .. code-block:: python
-#
-#    pip install -U torchdata
-#    pip install -U spacy
-#    python -m spacy download en_core_web_sm
-#    python -m spacy download de_core_news_sm
-
-token_transform[SRC_LANGUAGE] = get_tokenizer('spacy', language='de_core_news_sm')
-token_transform[TGT_LANGUAGE] = get_tokenizer('spacy', language='en_core_web_sm')
-
-
-# helper function to yield list of tokens
-def yield_tokens(data_iter: Iterable, language: str) -> List[str]:
-    language_index = {SRC_LANGUAGE: 0, TGT_LANGUAGE: 1}
-
-    for data_sample in data_iter:
-        yield token_transform[language](data_sample[language_index[language]])
-
-# Define special symbols and indices
-UNK_IDX, PAD_IDX, BOS_IDX, EOS_IDX = 0, 1, 2, 3
-# Make sure the tokens are in order of their indices to properly insert them in vocab
-special_symbols = ['<unk>', '<pad>', '<bos>', '<eos>']
-
-for ln in [SRC_LANGUAGE, TGT_LANGUAGE]:
-    # Training data Iterator
-    train_iter = Multi30k(split='train', language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))
-    # Create torchtext's Vocab object
-    vocab_transform[ln] = build_vocab_from_iterator(yield_tokens(train_iter, ln),
-                                                    min_freq=1,
-                                                    specials=special_symbols,
-                                                    special_first=True)
-
-# Set ``UNK_IDX`` as the default index. This index is returned when the token is not found.
-# If not set, it throws ``RuntimeError`` when the queried token is not found in the Vocabulary.
-for ln in [SRC_LANGUAGE, TGT_LANGUAGE]:
-  vocab_transform[ln].set_default_index(UNK_IDX)
-
-######################################################################
-# Seq2Seq Network using Transformer
-# ---------------------------------
-#
-# Transformer is a Seq2Seq model introduced in `“Attention is all you
-# need” <https://papers.nips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf>`__
-# paper for solving machine translation tasks.
-# Below, we will create a Seq2Seq network that uses Transformer. The network
-# consists of three parts. First part is the embedding layer. This layer converts tensor of input indices
-# into corresponding tensor of input embeddings. These embedding are further augmented with positional
-# encodings to provide position information of input tokens to the model. The second part is the
-# actual `Transformer <https://pytorch.org/docs/stable/generated/torch.nn.Transformer.html>`__ model.
-# Finally, the output of the Transformer model is passed through linear layer
-# that gives unnormalized probabilities for each token in the target language.
-#
-
-
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import Transformer
-import math
-DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-# helper Module that adds positional encoding to the token embedding to introduce a notion of word order.
-class PositionalEncoding(nn.Module):
-    def __init__(self,
-                 emb_size: int,
-                 dropout: float,
-                 maxlen: int = 5000):
-        super(PositionalEncoding, self).__init__()
-        den = torch.exp(- torch.arange(0, emb_size, 2)* math.log(10000) / emb_size)
-        pos = torch.arange(0, maxlen).reshape(maxlen, 1)
-        pos_embedding = torch.zeros((maxlen, emb_size))
-        pos_embedding[:, 0::2] = torch.sin(pos * den)
-        pos_embedding[:, 1::2] = torch.cos(pos * den)
-        pos_embedding = pos_embedding.unsqueeze(-2)
-
-        self.dropout = nn.Dropout(dropout)
-        self.register_buffer('pos_embedding', pos_embedding)
-
-    def forward(self, token_embedding: Tensor):
-        return self.dropout(token_embedding + self.pos_embedding[:token_embedding.size(0), :])
-
-# helper Module to convert tensor of input indices into corresponding tensor of token embeddings
-class TokenEmbedding(nn.Module):
-    def __init__(self, vocab_size: int, emb_size):
-        super(TokenEmbedding, self).__init__()
-        self.embedding = nn.Embedding(vocab_size, emb_size)
-        self.emb_size = emb_size
-
-    def forward(self, tokens: Tensor):
-        return self.embedding(tokens.long()) * math.sqrt(self.emb_size)
-
-# Seq2Seq Network
-class Seq2SeqTransformer(nn.Module):
-    def __init__(self,
-                 num_encoder_layers: int,
-                 num_decoder_layers: int,
-                 emb_size: int,
-                 nhead: int,
-                 src_vocab_size: int,
-                 tgt_vocab_size: int,
-                 dim_feedforward: int = 512,
-                 dropout: float = 0.1):
-        super(Seq2SeqTransformer, self).__init__()
-        self.transformer = Transformer(d_model=emb_size,
-                                       nhead=nhead,
-                                       num_encoder_layers=num_encoder_layers,
-                                       num_decoder_layers=num_decoder_layers,
-                                       dim_feedforward=dim_feedforward,
-                                       dropout=dropout)
-        self.generator = nn.Linear(emb_size, tgt_vocab_size)
-        self.src_tok_emb = TokenEmbedding(src_vocab_size, emb_size)
-        self.tgt_tok_emb = TokenEmbedding(tgt_vocab_size, emb_size)
-        self.positional_encoding = PositionalEncoding(
-            emb_size, dropout=dropout)
-
-    def forward(self,
-                src: Tensor,
-                trg: Tensor,
-                src_mask: Tensor,
-                tgt_mask: Tensor,
-                src_padding_mask: Tensor,
-                tgt_padding_mask: Tensor,
-                memory_key_padding_mask: Tensor):
-        src_emb = self.positional_encoding(self.src_tok_emb(src))
-        tgt_emb = self.positional_encoding(self.tgt_tok_emb(trg))
-        outs = self.transformer(src_emb, tgt_emb, src_mask, tgt_mask, None,
-                                src_padding_mask, tgt_padding_mask, memory_key_padding_mask)
-        return self.generator(outs)
-
-    def encode(self, src: Tensor, src_mask: Tensor):
-        return self.transformer.encoder(self.positional_encoding(
-                            self.src_tok_emb(src)), src_mask)
-
-    def decode(self, tgt: Tensor, memory: Tensor, tgt_mask: Tensor):
-        return self.transformer.decoder(self.positional_encoding(
-                          self.tgt_tok_emb(tgt)), memory,
-                          tgt_mask)
-
-
-######################################################################
-# During training, we need a subsequent word mask that will prevent the model from looking into
-# the future words when making predictions. We will also need masks to hide
-# source and target padding tokens. Below, let's define a function that will take care of both.
-#
-
-
-def generate_square_subsequent_mask(sz):
-    mask = (torch.triu(torch.ones((sz, sz), device=DEVICE)) == 1).transpose(0, 1)
-    mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
-    return mask
-
-
-def create_mask(src, tgt):
-    src_seq_len = src.shape[0]
-    tgt_seq_len = tgt.shape[0]
-
-    tgt_mask = generate_square_subsequent_mask(tgt_seq_len)
-    src_mask = torch.zeros((src_seq_len, src_seq_len),device=DEVICE).type(torch.bool)
-
-    src_padding_mask = (src == PAD_IDX).transpose(0, 1)
-    tgt_padding_mask = (tgt == PAD_IDX).transpose(0, 1)
-    return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask
-
-
-######################################################################
-# Let's now define the parameters of our model and instantiate the same. Below, we also
-# define our loss function which is the cross-entropy loss and the optimizer used for training.
-#
-torch.manual_seed(0)
-
-SRC_VOCAB_SIZE = len(vocab_transform[SRC_LANGUAGE])
-TGT_VOCAB_SIZE = len(vocab_transform[TGT_LANGUAGE])
-EMB_SIZE = 512
-NHEAD = 8
-FFN_HID_DIM = 512
-BATCH_SIZE = 128
-NUM_ENCODER_LAYERS = 3
-NUM_DECODER_LAYERS = 3
-
-transformer = Seq2SeqTransformer(NUM_ENCODER_LAYERS, NUM_DECODER_LAYERS, EMB_SIZE,
-                                 NHEAD, SRC_VOCAB_SIZE, TGT_VOCAB_SIZE, FFN_HID_DIM)
-
-for p in transformer.parameters():
-    if p.dim() > 1:
-        nn.init.xavier_uniform_(p)
-
-transformer = transformer.to(DEVICE)
-
-loss_fn = torch.nn.CrossEntropyLoss(ignore_index=PAD_IDX)
-
-optimizer = torch.optim.Adam(transformer.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9)
-
-######################################################################
-# Collation
-# ---------
-#
-# As seen in the ``Data Sourcing and Processing`` section, our data iterator yields a pair of raw strings.
-# We need to convert these string pairs into the batched tensors that can be processed by our ``Seq2Seq`` network
-# defined previously. Below we define our collate function that converts a batch of raw strings into batch tensors that
-# can be fed directly into our model.
-#
-
-
-from torch.nn.utils.rnn import pad_sequence
-
-# helper function to club together sequential operations
-def sequential_transforms(*transforms):
-    def func(txt_input):
-        for transform in transforms:
-            txt_input = transform(txt_input)
-        return txt_input
-    return func
-
-# function to add BOS/EOS and create tensor for input sequence indices
-def tensor_transform(token_ids: List[int]):
-    return torch.cat((torch.tensor([BOS_IDX]),
-                      torch.tensor(token_ids),
-                      torch.tensor([EOS_IDX])))
-
-# ``src`` and ``tgt`` language text transforms to convert raw strings into tensors indices
-text_transform = {}
-for ln in [SRC_LANGUAGE, TGT_LANGUAGE]:
-    text_transform[ln] = sequential_transforms(token_transform[ln], #Tokenization
-                                               vocab_transform[ln], #Numericalization
-                                               tensor_transform) # Add BOS/EOS and create tensor
-
-
-# function to collate data samples into batch tensors
-def collate_fn(batch):
-    src_batch, tgt_batch = [], []
-    for src_sample, tgt_sample in batch:
-        src_batch.append(text_transform[SRC_LANGUAGE](src_sample.rstrip("\n")))
-        tgt_batch.append(text_transform[TGT_LANGUAGE](tgt_sample.rstrip("\n")))
-
-    src_batch = pad_sequence(src_batch, padding_value=PAD_IDX)
-    tgt_batch = pad_sequence(tgt_batch, padding_value=PAD_IDX)
-    return src_batch, tgt_batch
-
-######################################################################
-# Let's define training and evaluation loop that will be called for each
-# epoch.
-#
-
-from torch.utils.data import DataLoader
-
-def train_epoch(model, optimizer):
-    model.train()
-    losses = 0
-    train_iter = Multi30k(split='train', language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))
-    train_dataloader = DataLoader(train_iter, batch_size=BATCH_SIZE, collate_fn=collate_fn)
-
-    for src, tgt in train_dataloader:
-        src = src.to(DEVICE)
-        tgt = tgt.to(DEVICE)
-
-        tgt_input = tgt[:-1, :]
-
-        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)
-
-        logits = model(src, tgt_input, src_mask, tgt_mask,src_padding_mask, tgt_padding_mask, src_padding_mask)
-
-        optimizer.zero_grad()
-
-        tgt_out = tgt[1:, :]
-        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
-        loss.backward()
-
-        optimizer.step()
-        losses += loss.item()
-
-    return losses / len(list(train_dataloader))
-
-
-def evaluate(model):
-    model.eval()
-    losses = 0
-
-    val_iter = Multi30k(split='valid', language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))
-    val_dataloader = DataLoader(val_iter, batch_size=BATCH_SIZE, collate_fn=collate_fn)
-
-    for src, tgt in val_dataloader:
-        src = src.to(DEVICE)
-        tgt = tgt.to(DEVICE)
-
-        tgt_input = tgt[:-1, :]
-
-        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)
-
-        logits = model(src, tgt_input, src_mask, tgt_mask,src_padding_mask, tgt_padding_mask, src_padding_mask)
-
-        tgt_out = tgt[1:, :]
-        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
-        losses += loss.item()
-
-    return losses / len(list(val_dataloader))
-
-######################################################################
-# Now we have all the ingredients to train our model. Let's do it!
-#
-
-from timeit import default_timer as timer
-NUM_EPOCHS = 18
-
-for epoch in range(1, NUM_EPOCHS+1):
-    start_time = timer()
-    train_loss = train_epoch(transformer, optimizer)
-    end_time = timer()
-    val_loss = evaluate(transformer)
-    print((f"Epoch: {epoch}, Train loss: {train_loss:.3f}, Val loss: {val_loss:.3f}, "f"Epoch time = {(end_time - start_time):.3f}s"))
-
-
-# function to generate output sequence using greedy algorithm
-def greedy_decode(model, src, src_mask, max_len, start_symbol):
-    src = src.to(DEVICE)
-    src_mask = src_mask.to(DEVICE)
-
-    memory = model.encode(src, src_mask)
-    ys = torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(DEVICE)
-    for i in range(max_len-1):
-        memory = memory.to(DEVICE)
-        tgt_mask = (generate_square_subsequent_mask(ys.size(0))
-                    .type(torch.bool)).to(DEVICE)
-        out = model.decode(ys, memory, tgt_mask)
-        out = out.transpose(0, 1)
-        prob = model.generator(out[:, -1])
-        _, next_word = torch.max(prob, dim=1)
-        next_word = next_word.item()
-
-        ys = torch.cat([ys,
-                        torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=0)
-        if next_word == EOS_IDX:
-            break
-    return ys
-
-
-# actual function to translate input sentence into target language
-def translate(model: torch.nn.Module, src_sentence: str):
-    model.eval()
-    src = text_transform[SRC_LANGUAGE](src_sentence).view(-1, 1)
-    num_tokens = src.shape[0]
-    src_mask = (torch.zeros(num_tokens, num_tokens)).type(torch.bool)
-    tgt_tokens = greedy_decode(
-        model,  src, src_mask, max_len=num_tokens + 5, start_symbol=BOS_IDX).flatten()
-    return " ".join(vocab_transform[TGT_LANGUAGE].lookup_tokens(list(tgt_tokens.cpu().numpy()))).replace("<bos>", "").replace("<eos>", "")
-
-
-######################################################################
-#
-
-print(translate(transformer, "Eine Gruppe von Menschen steht vor einem Iglu ."))
-
-
-######################################################################
-# References
-# ----------
-#
-# 1. Attention is all you need paper.
-#    https://papers.nips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf
-# 2. The annotated transformer. https://nlp.seas.harvard.edu/2018/04/03/attention.html#positional-encoding
diff --git a/beginner_source/translation_transformer.rst b/beginner_source/translation_transformer.rst
new file mode 100644
index 0000000000..892c1b73ca
--- /dev/null
+++ b/beginner_source/translation_transformer.rst
@@ -0,0 +1,10 @@
+Language Translation with ``nn.Transformer`` and torchtext
+==========================================================
+
+This tutorial has been deprecated.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/'" />
diff --git a/conf.py b/conf.py
index 4ab380a7b3..a12a05d21c 100644
--- a/conf.py
+++ b/conf.py
@@ -45,6 +45,7 @@
 import pandocfilters
 import pypandoc
 import plotly.io as pio
+from pathlib import Path
 pio.renderers.default = 'sphinx_gallery'
 
 
@@ -140,22 +141,17 @@ def reset_seeds(gallery_conf, fname):
     sphinx_gallery_conf['ignore_pattern'] = r'/(?!' + re.escape(os.getenv('GALLERY_PATTERN')) + r')[^/]+$'
 
 for i in range(len(sphinx_gallery_conf['examples_dirs'])):
-    gallery_dir = sphinx_gallery_conf['gallery_dirs'][i]
-    source_dir = sphinx_gallery_conf['examples_dirs'][i]
-    # Create gallery dirs if it doesn't exist
-    try:
-        os.mkdir(gallery_dir)
-    except OSError:
-        pass
+    gallery_dir = Path(sphinx_gallery_conf["gallery_dirs"][i])
+    source_dir = Path(sphinx_gallery_conf["examples_dirs"][i])
 
     # Copy rst files from source dir to gallery dir
-    for f in glob.glob(os.path.join(source_dir, '*.rst')):
-        distutils.file_util.copy_file(f, gallery_dir, update=True)
-
+    for f in source_dir.rglob("*.rst"):
+        f_dir = Path(f).parent
+        gallery_subdir_path = gallery_dir / f_dir.relative_to(source_dir)
+        gallery_subdir_path.mkdir(parents=True, exist_ok=True)
+        distutils.file_util.copy_file(f, gallery_subdir_path, update=True)
 
 # Add any paths that contain templates here, relative to this directory.
-
-
 templates_path = ['_templates']
 
 # The suffix(es) of source filenames.
@@ -308,6 +304,10 @@ def reset_seeds(gallery_conf, fname):
         'css/custom2.css'
     ]
 
+html_js_files = [
+    "js/custom.js",
+]
+
 def setup(app):
     # NOTE: in Sphinx 1.8+ `html_css_files` is an official configuration value
     # and can be moved outside of this function (and the setup(app) function
diff --git a/distributed/home.rst b/distributed/home.rst
index 41e648ff62..c2c5365706 100644
--- a/distributed/home.rst
+++ b/distributed/home.rst
@@ -77,7 +77,7 @@ Learn FSDP
 
      .. grid-item-card:: :octicon:`file-code;1em`
         FSDP Advanced
-        :link: https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html?utm_source=distr_landing&utm_medium=FSDP_advanced
+        :link: https://pytorch.org/tutorials/intermediate/FSDP_advanced_tutorial.html?utm_source=distr_landing&utm_medium=FSDP_advanced
         :link-type: url
 
         In this tutorial, you will learn how to fine-tune a HuggingFace (HF) T5
diff --git a/en-wordlist.txt b/en-wordlist.txt
index bdc49536e2..8a118b941b 100644
--- a/en-wordlist.txt
+++ b/en-wordlist.txt
@@ -1,4 +1,3 @@
-
 ACL
 ADI
 AOT
@@ -68,6 +67,7 @@ DyNet
 EOS
 EPS
 Ecker
+ExecuTorch
 ExportDB
 FC
 FGSM
@@ -187,6 +187,7 @@ PIL's
 PPO
 PatchPredictor
 PennFudan
+Perfetto
 Pixman
 Plotly
 Pohjonen
@@ -647,4 +648,11 @@ url
 colab
 sharders
 Criteo
-torchrec
\ No newline at end of file
+torchrec
+_batch_norm_impl_index
+convolution_overrideable
+aten
+XPU
+XPUs
+impl
+overrideable
diff --git a/index.rst b/index.rst
index 94610581e4..86592b2241 100644
--- a/index.rst
+++ b/index.rst
@@ -3,13 +3,13 @@ Welcome to PyTorch Tutorials
 
 **What's new in PyTorch tutorials?**
 
-* `torch.export AOTInductor Tutorial for Python runtime (Beta) <https://pytorch.org/tutorials/recipes/torch_export_aoti_python.html>`__
-* `A guide on good usage of non_blocking and pin_memory() in PyTorch <https://pytorch.org/tutorials/intermediate/pinmem_nonblock.html>`__
-* `Introduction to Distributed Pipeline Parallelism <https://pytorch.org/tutorials/intermediate/pipelining_tutorial.html>`__
-* `Introduction to Libuv TCPStore Backend <https://pytorch.org/tutorials/intermediate/TCPStore_libuv_backend.html>`__ 
-* `Asynchronous Saving with Distributed Checkpoint (DCP) <https://pytorch.org/tutorials/recipes/distributed_async_checkpoint_recipe.html>`__
-* `Python Custom Operators <https://pytorch.org/tutorials/advanced/python_custom_ops.html>`__
-* Updated `Getting Started with DeviceMesh <https://pytorch.org/tutorials/recipes/distributed_device_mesh.html>`__
+* `Compiled Autograd: Capturing a larger backward graph for torch.compile <https://pytorch.org/tutorials/intermediate/compiled_autograd_tutorial>`__
+* `Reducing torch.compile cold start compilation time with regional compilation <https://pytorch.org/tutorials/recipes/regional_compilation.html>`__
+* `Introduction to TorchRec <https://pytorch.org/tutorials/intermediate/torchrec_intro_tutorial.html>`__
+* `(prototype) Flight Recorder for Debugging Stuck Jobs <https://pytorch.org/tutorials/prototype/flight_recorder_tutorial.html>`__
+* `(prototype) How to use TorchInductor on Windows CPU <https://pytorch.org/tutorials/prototype/inductor_windows_cpu.html>`__
+* `(prototype) Using Max-Autotune Compilation on CPU for Better Performance <https://pytorch.org/tutorials/prototype/max_autotune_on_CPU_tutorial.html>`__
+* `(prototype) Autoloading Out-of-Tree Extension <https://pytorch.org/tutorials/prototype/python_extension_autoload.html>`__
 
 .. raw:: html
 
@@ -71,7 +71,7 @@ Welcome to PyTorch Tutorials
    :header: Introduction to PyTorch on YouTube
    :card_description: An introduction to building a complete ML workflow with PyTorch. Follows the PyTorch Beginner Series on YouTube.
    :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
-   :link: beginner/introyt.html
+   :link: beginner/introyt/introyt_index.html
    :tags: Getting-Started
 
 .. customcarditem::
@@ -232,57 +232,28 @@ Welcome to PyTorch Tutorials
    :link: intermediate/forced_alignment_with_torchaudio_tutorial.html
    :tags: Audio
 
-.. Text
-
-.. customcarditem::
-   :header: Fast Transformer Inference with Better Transformer
-   :card_description: Deploy a PyTorch Transformer model using Better Transformer with high performance for inference
-   :image: _static/img/thumbnails/cropped/pytorch-logo.png
-   :link: beginner/bettertransformer_tutorial.html
-   :tags: Production,Text
+.. NLP
 
 .. customcarditem::
    :header: NLP from Scratch: Classifying Names with a Character-level RNN
    :card_description: Build and train a basic character-level RNN to classify word from scratch without the use of torchtext. First in a series of three tutorials.
    :image: _static/img/thumbnails/cropped/NLP-From-Scratch-Classifying-Names-with-a-Character-Level-RNN.png
    :link: intermediate/char_rnn_classification_tutorial
-   :tags: Text
+   :tags: NLP
 
 .. customcarditem::
    :header: NLP from Scratch: Generating Names with a Character-level RNN
    :card_description: After using character-level RNN to classify names, learn how to generate names from languages. Second in a series of three tutorials.
    :image: _static/img/thumbnails/cropped/NLP-From-Scratch-Generating-Names-with-a-Character-Level-RNN.png
    :link: intermediate/char_rnn_generation_tutorial.html
-   :tags: Text
+   :tags: NLP
 
 .. customcarditem::
    :header: NLP from Scratch: Translation with a Sequence-to-sequence Network and Attention
    :card_description: This is the third and final tutorial on doing “NLP From Scratch”, where we write our own classes and functions to preprocess the data to do our NLP modeling tasks.
    :image: _static/img/thumbnails/cropped/NLP-From-Scratch-Translation-with-a-Sequence-to-Sequence-Network-and-Attention.png
    :link: intermediate/seq2seq_translation_tutorial.html
-   :tags: Text
-
-.. customcarditem::
-   :header: Text Classification with Torchtext
-   :card_description: Learn how to build the dataset and classify text using torchtext library.
-   :image: _static/img/thumbnails/cropped/Text-Classification-with-TorchText.png
-   :link: beginner/text_sentiment_ngrams_tutorial.html
-   :tags: Text
-
-.. customcarditem::
-   :header: Language Translation with Transformer
-   :card_description: Train a language translation model from scratch using Transformer.
-   :image: _static/img/thumbnails/cropped/Language-Translation-with-TorchText.png
-   :link: beginner/translation_transformer.html
-   :tags: Text
-
-.. customcarditem::
-   :header: Pre-process custom text dataset using Torchtext
-   :card_description: Learn how to use torchtext to prepare a custom dataset
-   :image: _static/img/thumbnails/cropped/torch_text_logo.png
-   :link: beginner/torchtext_custom_dataset_tutorial.html
-   :tags: Text
-
+   :tags: NLP
 
 .. ONNX
 
@@ -792,7 +763,7 @@ Welcome to PyTorch Tutorials
    :header: Advanced Model Training with Fully Sharded Data Parallel (FSDP)
    :card_description: Explore advanced model training with Fully Sharded Data Parallel package.
    :image: _static/img/thumbnails/cropped/Getting-Started-with-FSDP.png
-   :link: intermediate/FSDP_adavnced_tutorial.html
+   :link: intermediate/FSDP_advanced_tutorial.html
    :tags: Parallel-and-Distributed-Training
 
 .. customcarditem::
@@ -935,7 +906,7 @@ Additional Resources
 .. Page TOC
 .. -----------------------------------------
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
    :hidden:
    :includehidden:
    :caption: PyTorch Recipes
@@ -944,39 +915,15 @@ Additional Resources
    See All Prototype Recipes <prototype/prototype_index>
 
 .. toctree::
-   :maxdepth: 2
    :hidden:
    :includehidden:
    :caption: Introduction to PyTorch
 
    beginner/basics/intro
-   beginner/basics/quickstart_tutorial
-   beginner/basics/tensorqs_tutorial
-   beginner/basics/data_tutorial
-   beginner/basics/transforms_tutorial
-   beginner/basics/buildmodel_tutorial
-   beginner/basics/autogradqs_tutorial
-   beginner/basics/optimization_tutorial
-   beginner/basics/saveloadrun_tutorial
-   advanced/custom_ops_landing_page
-
-.. toctree::
-   :maxdepth: 2
-   :hidden:
-   :includehidden:
-   :caption: Introduction to PyTorch on YouTube
-
-   beginner/introyt
-   beginner/introyt/introyt1_tutorial
-   beginner/introyt/tensors_deeper_tutorial
-   beginner/introyt/autogradyt_tutorial
-   beginner/introyt/modelsyt_tutorial
-   beginner/introyt/tensorboardyt_tutorial
-   beginner/introyt/trainingyt
-   beginner/introyt/captumyt
+   beginner/introyt/introyt_index
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
    :hidden:
    :includehidden:
    :caption: Learning PyTorch
@@ -984,11 +931,12 @@ Additional Resources
    beginner/deep_learning_60min_blitz
    beginner/pytorch_with_examples
    beginner/nn_tutorial
+   intermediate/nlp_from_scratch_index
    intermediate/tensorboard_tutorial
    intermediate/pinmem_nonblock
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
    :includehidden:
    :hidden:
    :caption: Image and Video
@@ -1019,22 +967,7 @@ Additional Resources
    intermediate/forced_alignment_with_torchaudio_tutorial
 
 .. toctree::
-   :maxdepth: 2
-   :includehidden:
-   :hidden:
-   :caption: Text
-
-   beginner/bettertransformer_tutorial
-   intermediate/char_rnn_classification_tutorial
-   intermediate/char_rnn_generation_tutorial
-   intermediate/seq2seq_translation_tutorial
-   beginner/text_sentiment_ngrams_tutorial
-   beginner/translation_transformer
-   beginner/torchtext_custom_dataset_tutorial
-
-
-.. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
    :includehidden:
    :hidden:
    :caption: Backends
@@ -1053,7 +986,7 @@ Additional Resources
    advanced/pendulum
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
    :includehidden:
    :hidden:
    :caption: Deploying PyTorch Models in Production
@@ -1158,7 +1091,7 @@ Additional Resources
    intermediate/ddp_tutorial
    intermediate/dist_tuto
    intermediate/FSDP_tutorial
-   intermediate/FSDP_adavnced_tutorial
+   intermediate/FSDP_advanced_tutorial
    intermediate/TCPStore_libuv_backend
    intermediate/TP_tutorial
    intermediate/pipelining_tutorial
diff --git a/intermediate_source/FSDP_adavnced_tutorial.rst b/intermediate_source/FSDP_advanced_tutorial.rst
similarity index 93%
rename from intermediate_source/FSDP_adavnced_tutorial.rst
rename to intermediate_source/FSDP_advanced_tutorial.rst
index f7ee1e7de1..bf22e6efb5 100644
--- a/intermediate_source/FSDP_adavnced_tutorial.rst
+++ b/intermediate_source/FSDP_advanced_tutorial.rst
@@ -6,6 +6,23 @@ Wright <https://github.com/lessw2020>`__, `Rohan Varma
 <https://github.com/rohan-varma/>`__, `Yanli Zhao
 <https://github.com/zhaojuanmao>`__
 
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+
+      * PyTorch's Fully Sharded Data Parallel Module: A wrapper for sharding module parameters across
+      data parallel workers.
+
+
+
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+
+      * PyTorch 1.12 or later
+      * Read about the `FSDP API <https://pytorch.org/docs/main/fsdp.html>`__.
+
 
 This tutorial introduces more advanced features of Fully Sharded Data Parallel
 (FSDP) as part of the PyTorch 1.12 release. To get familiar with FSDP, please
@@ -13,18 +30,20 @@ refer to the `FSDP getting started tutorial
 <https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__.
 
 In this tutorial, we fine-tune a HuggingFace (HF) T5 model with FSDP for text
-summarization as a working example. 
+summarization as a working example.
 
 The example uses Wikihow and for simplicity, we will showcase the training on a
-single node, P4dn instance with 8 A100 GPUs. We will soon have a blog post on
-large scale FSDP training on a multi-node cluster, please stay tuned for that on
-the PyTorch medium channel.
+single node, P4dn instance with 8 A100 GPUs. We now have several blog posts (
+`(link1), <https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/>`__
+`(link2) <https://engineering.fb.com/2021/07/15/open-source/fsdp/>`__)
+and a `paper <https://arxiv.org/abs/2304.11277>`__ on
+large scale FSDP training on a multi-node cluster.
 
 FSDP is a production ready package with focus on ease of use, performance, and
 long-term support.  One of the main benefits of FSDP is reducing the memory
 footprint on each GPU. This enables training of larger models with lower total
 memory vs DDP, and leverages the overlap of computation and communication to
-train models efficiently. 
+train models efficiently.
 This reduced memory pressure can be leveraged to either train larger models or
 increase batch size, potentially helping overall training throughput.  You can
 read more about PyTorch FSDP `here
@@ -47,21 +66,21 @@ Recap on How FSDP Works
 
 At a high level FDSP works as follow:
 
-*In constructor*
+*In the constructor*
 
 * Shard model parameters and each rank only keeps its own shard
 
-*In forward pass*
+*In the forward pass*
 
 * Run `all_gather` to collect all shards from all ranks to recover the full
-  parameter for this FSDP unit Run forward computation
-* Discard non-owned parameter shards it has just collected to free memory
+  parameter for this FSDP unit and run the forward computation
+* Discard the non-owned parameter shards it has just collected to free memory
 
-*In backward pass*
+*In the backward pass*
 
 * Run `all_gather` to collect all shards from all ranks to recover the full
-  parameter in this FSDP unit Run backward computation
-* Discard non-owned parameters to free memory. 
+  parameter in this FSDP unit and run backward computation
+* Discard non-owned parameters to free memory.
 * Run reduce_scatter to sync gradients
 
 
@@ -80,15 +99,11 @@ examples
 
 *Setup*
 
-1.1 Install PyTorch Nightlies
-
-We will install PyTorch nightlies, as some of the features such as activation
-checkpointing is available in nightlies and will be added in next PyTorch
-release after 1.12.
+1.1 Install the latest PyTorch
 
-.. code-block:: bash 
+.. code-block:: bash
 
-    pip3 install --pre torch torchvision torchaudio -f https://download.pytorch.org/whl/nightly/cu113/torch_nightly.html
+    pip3 install torch torchvision torchaudio
 
 1.2 Dataset Setup
 
@@ -154,7 +169,7 @@ Next, we add the following code snippets to a Python script “T5_training.py”
     import tqdm
     from datetime import datetime
 
-1.4 Distributed training setup. 
+1.4 Distributed training setup.
 Here we use two helper functions to initialize the processes for distributed
 training,  and then to clean up after training completion.  In this tutorial, we
 are going to use torch elastic, using `torchrun
@@ -191,13 +206,13 @@ metrics.
         date_of_run = datetime.now().strftime("%Y-%m-%d-%I:%M:%S_%p")
         print(f"--> current date and time of run = {date_of_run}")
         return date_of_run
-   
+
     def format_metrics_to_gb(item):
         """quick function to format numbers to gigabyte and round to 4 digit precision"""
         metric_num = item / g_gigabyte
         metric_num = round(metric_num, ndigits=4)
         return metric_num
-    
+
 
 2.2 Define a train function:
 
@@ -275,7 +290,7 @@ metrics.
 
 .. code-block:: python
 
-    
+
     def fsdp_main(args):
 
         model, tokenizer = setup_model("t5-base")
@@ -292,7 +307,7 @@ metrics.
 
 
         #wikihow(tokenizer, type_path, num_samples, input_length, output_length, print_text=False)
-        train_dataset = wikihow(tokenizer, 'train', 1500, 512, 150, False) 
+        train_dataset = wikihow(tokenizer, 'train', 1500, 512, 150, False)
         val_dataset = wikihow(tokenizer, 'validation', 300, 512, 150, False)
 
         sampler1 = DistributedSampler(train_dataset, rank=rank, num_replicas=world_size, shuffle=True)
@@ -430,7 +445,7 @@ metrics.
 
 .. code-block:: python
 
-    
+
     if __name__ == '__main__':
         # Training settings
         parser = argparse.ArgumentParser(description='PyTorch T5 FSDP Example')
@@ -463,7 +478,7 @@ metrics.
 
 To run the the training using torchrun:
 
-.. code-block:: bash 
+.. code-block:: bash
 
     torchrun --nnodes 1 --nproc_per_node 4  T5_training.py
 
@@ -487,7 +502,7 @@ communication efficient.  In PyTorch 1.12, FSDP added this support and now we
 have a wrapping policy for transfomers.
 
 It can be created as follows, where the T5Block represents the T5 transformer
-layer class (holding MHSA and FFN).  
+layer class (holding MHSA and FFN).
 
 
 .. code-block:: python
@@ -499,7 +514,7 @@ layer class (holding MHSA and FFN).
             },
         )
     torch.cuda.set_device(local_rank)
-  
+
 
     model = FSDP(model,
         auto_wrap_policy=t5_auto_wrap_policy)
@@ -513,22 +528,22 @@ Mixed Precision
 FSDP supports flexible mixed precision training allowing for arbitrary reduced
 precision types (such as fp16 or bfloat16). Currently BFloat16 is only available
 on Ampere GPUs, so you need to confirm native support before you use it. On
-V100s for example, BFloat16 can still be run but due to it running non-natively,
+V100s for example, BFloat16 can still be run but because it runs non-natively,
 it can result in significant slowdowns.
 
 To check if BFloat16 is natively supported, you can use the following :
 
 .. code-block:: python
-    
+
     bf16_ready = (
         torch.version.cuda
-        and torch.cuda.is_bf16_supported() 
+        and torch.cuda.is_bf16_supported()
         and LooseVersion(torch.version.cuda) >= "11.0"
         and dist.is_nccl_available()
         and nccl.version() >= (2, 10)
     )
 
-One of the advantages of mixed percision in FSDP is providing granular control
+One of the advantages of mixed precision in FSDP is providing granular control
 over different precision levels for parameters, gradients, and buffers as
 follows:
 
@@ -571,7 +586,7 @@ with the following policy:
 .. code-block:: bash
 
     grad_bf16 = MixedPrecision(reduce_dtype=torch.bfloat16)
-    
+
 
 In 2.4 we just add the relevant mixed precision policy to the FSDP wrapper:
 
@@ -604,9 +619,9 @@ CPU-based initialization:
             auto_wrap_policy=t5_auto_wrap_policy,
             mixed_precision=bfSixteen,
             device_id=torch.cuda.current_device())
-     
 
-    
+
+
 Sharding Strategy
 -----------------
 FSDP sharding strategy by default is set to fully shard the model parameters,
@@ -627,7 +642,7 @@ instead of "ShardingStrategy.FULL_SHARD" to the FSDP initialization  as follows:
             sharding_strategy=ShardingStrategy.SHARD_GRAD_OP # ZERO2)
 
 This will reduce the communication overhead in FSDP, in this case, it holds full
-parameters after forward and through the backwards pass. 
+parameters after forward and through the backwards pass.
 
 This saves an all_gather during backwards so there is less communication at the
 cost of a higher memory footprint. Note that full model params are freed at the
@@ -652,12 +667,12 @@ wrapper in 2.4 as follows:
             mixed_precision=bfSixteen,
             device_id=torch.cuda.current_device(),
             backward_prefetch = BackwardPrefetch.BACKWARD_PRE)
-            
+
 `backward_prefetch` has two modes, `BACKWARD_PRE` and `BACKWARD_POST`.
 `BACKWARD_POST` means that the next FSDP unit's params will not be requested
 until the current FSDP unit processing is complete, thus minimizing memory
 overhead.  In some cases, using `BACKWARD_PRE` can increase model training speed
-up to 2-10%, with even higher speed improvements noted for larger models. 
+up to 2-10%, with even higher speed improvements noted for larger models.
 
 Model Checkpoint Saving, by streaming to the Rank0 CPU
 ------------------------------------------------------
@@ -696,7 +711,7 @@ Pytorch 1.12 and used HF T5 as the running example.  Using the proper wrapping
 policy especially for transformer models, along with mixed precision and
 backward prefetch should speed up your training runs. Also, features such as
 initializing the model on device, and checkpoint saving via streaming to CPU
-should help to avoid OOM error in dealing with large models. 
+should help to avoid OOM error in dealing with large models.
 
 We are actively working to add new features to FSDP for the next release. If
 you have feedback, feature requests, questions or are encountering issues
diff --git a/intermediate_source/char_rnn_classification_tutorial.py b/intermediate_source/char_rnn_classification_tutorial.py
index 8451f07b82..2bae524b4a 100644
--- a/intermediate_source/char_rnn_classification_tutorial.py
+++ b/intermediate_source/char_rnn_classification_tutorial.py
@@ -4,13 +4,18 @@
 **************************************************************
 **Author**: `Sean Robertson <https://github.com/spro>`_
 
+This tutorials is part of a three-part series:
+
+* `NLP From Scratch: Classifying Names with a Character-Level RNN <https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html>`__
+* `NLP From Scratch: Generating Names with a Character-Level RNN <https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html>`__
+* `NLP From Scratch: Translation with a Sequence to Sequence Network and Attention <https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html>`__
+
 We will be building and training a basic character-level Recurrent Neural
 Network (RNN) to classify words. This tutorial, along with two other
 Natural Language Processing (NLP) "from scratch" tutorials
 :doc:`/intermediate/char_rnn_generation_tutorial` and
 :doc:`/intermediate/seq2seq_translation_tutorial`, show how to
-preprocess data to model NLP. In particular these tutorials do not
-use many of the convenience functions of `torchtext`, so you can see how
+preprocess data to model NLP. In particular, these tutorials show how
 preprocessing to model NLP works at a low level.
 
 A character-level RNN reads words as a series of characters -
diff --git a/intermediate_source/char_rnn_generation_tutorial.py b/intermediate_source/char_rnn_generation_tutorial.py
index f7db4769ed..50a6afa11b 100644
--- a/intermediate_source/char_rnn_generation_tutorial.py
+++ b/intermediate_source/char_rnn_generation_tutorial.py
@@ -4,6 +4,12 @@
 *************************************************************
 **Author**: `Sean Robertson <https://github.com/spro>`_
 
+This tutorials is part of a three-part series:
+
+* `NLP From Scratch: Classifying Names with a Character-Level RNN <https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html>`__
+* `NLP From Scratch: Generating Names with a Character-Level RNN <https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html>`__
+* `NLP From Scratch: Translation with a Sequence to Sequence Network and Attention <https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html>`__
+
 This is our second of three tutorials on "NLP From Scratch".
 In the `first tutorial </tutorials/intermediate/char_rnn_classification_tutorial>`_
 we used a RNN to classify names into their language of origin. This time
diff --git a/intermediate_source/compiled_autograd_tutorial.rst b/intermediate_source/compiled_autograd_tutorial.rst
index bcae7e63da..1091b19a49 100644
--- a/intermediate_source/compiled_autograd_tutorial.rst
+++ b/intermediate_source/compiled_autograd_tutorial.rst
@@ -97,62 +97,10 @@ Run the script with the ``TORCH_LOGS`` environment variables:
 Rerun the snippet above, the compiled autograd graph should now be logged to ``stderr``. Certain graph nodes will have names that are prefixed by ``aot0_``,
 these correspond to the nodes previously compiled ahead of time in AOTAutograd backward graph 0, for example, ``aot0_view_2`` corresponds to ``view_2`` of the AOT backward graph with id=0.
 
+In the image below, the red box encapsulates the AOT backward graph that is captured by ``torch.compile`` without Compiled Autograd.
 
-.. code:: python
 
-   stderr_output = """
-   DEBUG:torch._dynamo.compiled_autograd.__compiled_autograd_verbose:Cache miss due to new autograd node: torch::autograd::GraphRoot (NodeCall 0) with key size 39, previous key sizes=[]
-   DEBUG:torch._dynamo.compiled_autograd.__compiled_autograd_verbose:TRACED GRAPH
-   ===== Compiled autograd graph =====
-   <eval_with_key>.4 class CompiledAutograd(torch.nn.Module):
-      def forward(self, inputs, sizes, scalars, hooks):
-         # No stacktrace found for following nodes
-         aot0_tangents_1: "f32[][]cpu" = inputs[0]
-         aot0_primals_3: "f32[10][1]cpu" = inputs[1]
-         getitem_2: "f32[10][1]cpu" = inputs[2]
-         getitem_3: "f32[10, 10][10, 1]cpu" = inputs[3];  inputs = None
-         
-            # File: /data/users/xmfan/a/pytorch/torch/_dynamo/compiled_autograd.py:483 in set_node_origin, code: CompiledFunctionBackward0 (NodeCall 1)
-         aot0_expand: "f32[10][0]cpu" = torch.ops.aten.expand.default(aot0_tangents_1, [10]);  aot0_tangents_1 = None
-         aot0_view_2: "f32[1, 10][0, 0]cpu" = torch.ops.aten.view.default(aot0_expand, [1, 10]);  aot0_expand = None
-         aot0_permute_2: "f32[10, 1][0, 0]cpu" = torch.ops.aten.permute.default(aot0_view_2, [1, 0])
-         aot0_select: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 0)
-         aot0_view: "f32[1, 10][10, 1]cpu" = torch.ops.aten.view.default(aot0_primals_3, [1, 10]);  aot0_primals_3 = None
-         aot0_mul_3: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select, aot0_view);  aot0_select = None
-         aot0_select_1: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 1)
-         aot0_mul_4: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_1, aot0_view);  aot0_select_1 = None
-         aot0_select_2: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 2)
-         aot0_mul_5: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_2, aot0_view);  aot0_select_2 = None
-         aot0_select_3: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 3)
-         aot0_mul_6: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_3, aot0_view);  aot0_select_3 = None
-         aot0_select_4: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 4)
-         aot0_mul_7: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_4, aot0_view);  aot0_select_4 = None
-         aot0_select_5: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 5)
-         aot0_mul_8: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_5, aot0_view);  aot0_select_5 = None
-         aot0_select_6: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 6)
-         aot0_mul_9: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_6, aot0_view);  aot0_select_6 = None
-         aot0_select_7: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 7)
-         aot0_mul_10: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_7, aot0_view);  aot0_select_7 = None
-         aot0_select_8: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 8)
-         aot0_mul_11: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_8, aot0_view);  aot0_select_8 = None
-         aot0_select_9: "f32[1][0]cpu" = torch.ops.aten.select.int(aot0_permute_2, 0, 9);  aot0_permute_2 = None
-         aot0_mul_12: "f32[1, 10][10, 1]cpu" = torch.ops.aten.mul.Tensor(aot0_select_9, aot0_view);  aot0_select_9 = aot0_view = None
-         aot0_cat: "f32[10, 10][10, 1]cpu" = torch.ops.aten.cat.default([aot0_mul_3, aot0_mul_4, aot0_mul_5, aot0_mul_6, aot0_mul_7, aot0_mul_8, aot0_mul_9, aot0_mul_10, aot0_mul_11, aot0_mul_12]);  aot0_mul_3 = aot0_mul_4 = aot0_mul_5 = aot0_mul_6 = aot0_mul_7 = aot0_mul_8 = aot0_mul_9 = aot0_mul_10 = aot0_mul_11 = aot0_mul_12 = None
-         aot0_permute_3: "f32[10, 10][1, 10]cpu" = torch.ops.aten.permute.default(aot0_cat, [1, 0]);  aot0_cat = None
-         aot0_sum_3: "f32[1, 10][10, 1]cpu" = torch.ops.aten.sum.dim_IntList(aot0_view_2, [0], True);  aot0_view_2 = None
-         aot0_view_3: "f32[10][1]cpu" = torch.ops.aten.view.default(aot0_sum_3, [10]);  aot0_sum_3 = None
-         
-            # File: /data/users/xmfan/a/pytorch/torch/_dynamo/compiled_autograd.py:483 in set_node_origin, code: torch::autograd::AccumulateGrad (NodeCall 2)
-         accumulate_grad_ = torch.ops.inductor.accumulate_grad_.default(getitem_2, aot0_view_3);  getitem_2 = aot0_view_3 = accumulate_grad_ = None
-         
-            # File: /data/users/xmfan/a/pytorch/torch/_dynamo/compiled_autograd.py:483 in set_node_origin, code: CompiledFunctionBackward0 (NodeCall 1)
-         aot0_permute_4: "f32[10, 10][10, 1]cpu" = torch.ops.aten.permute.default(aot0_permute_3, [1, 0]);  aot0_permute_3 = None
-         
-            # File: /data/users/xmfan/a/pytorch/torch/_dynamo/compiled_autograd.py:483 in set_node_origin, code: torch::autograd::AccumulateGrad (NodeCall 3)
-         accumulate_grad__1 = torch.ops.inductor.accumulate_grad_.default(getitem_3, aot0_permute_4);  getitem_3 = aot0_permute_4 = accumulate_grad__1 = None
-         _exec_final_callbacks_stub = torch__dynamo_external_utils__exec_final_callbacks_stub();  _exec_final_callbacks_stub = None
-         return []
-   """
+.. image:: ../_static/img/compiled_autograd/entire_verbose_log.png
 
 .. note:: This is the graph on which we will call ``torch.compile``, **NOT** the optimized graph. Compiled Autograd essentially generates some unoptimized Python code to represent the entire C++ autograd execution.
 
@@ -181,7 +129,7 @@ Or you can use the context manager, which will apply to all autograd calls withi
 
 Compiled Autograd addresses certain limitations of AOTAutograd
 --------------------------------------------------------------
-1. Graph breaks in the forward pass lead to graph breaks in the backward pass:
+1. Graph breaks in the forward pass no longer necessarily lead to graph breaks in the backward pass:
 
 .. code:: python
 
@@ -216,7 +164,10 @@ Compiled Autograd addresses certain limitations of AOTAutograd
 In the first ``torch.compile`` case, we see that 3 backward graphs were produced due to the 2 graph breaks in the compiled function ``fn``. 
 Whereas in the second ``torch.compile`` with compiled autograd case, we see that a full backward graph was traced despite the graph breaks.
 
-2. Backward hooks are not captured
+.. note:: It is still possible for the Dynamo to graph break when tracing backward hooks captured by Compiled Autograd.
+
+
+2. Backward hooks can now be captured
 
 .. code:: python
 
@@ -233,19 +184,7 @@ Whereas in the second ``torch.compile`` with compiled autograd case, we see that
 
 There should be a ``call_hook`` node in the graph, which dynamo will later inline into the following:
 
-.. code:: python
-
-   stderr_output = """
-   DEBUG:torch._dynamo.compiled_autograd.__compiled_autograd_verbose:Cache miss due to new autograd node: torch::autograd::GraphRoot (NodeCall 0) with key size 39, previous key sizes=[]
-   DEBUG:torch._dynamo.compiled_autograd.__compiled_autograd_verbose:TRACED GRAPH
-   ===== Compiled autograd graph =====
-   <eval_with_key>.2 class CompiledAutograd(torch.nn.Module):
-      def forward(self, inputs, sizes, scalars, hooks):
-         ...
-         getitem_2 = hooks[0];  hooks = None
-         call_hook: "f32[10, 10][0, 0]cpu" = torch__dynamo_external_utils_call_hook(getitem_2, aot0_expand, hook_type = 'tensor_pre_hook');  getitem_2 = aot0_expand = None
-         ...
-   """
+.. image:: ../_static/img/compiled_autograd/call_hook_node.png
 
 Common recompilation reasons for Compiled Autograd
 --------------------------------------------------
@@ -261,18 +200,7 @@ Common recompilation reasons for Compiled Autograd
 
 In the example above, we call a different operator on each iteration, leading to ``loss`` tracking a different autograd history each time. You should see some recompile messages: **Cache miss due to new autograd node**.
 
-.. code:: python
-
-   stderr_output = """
-   Cache miss due to new autograd node: torch::autograd::GraphRoot (NodeCall 0) with key size 39, previous key sizes=[] 
-   ...
-   Cache miss due to new autograd node: SubBackward0 (NodeCall 2) with key size 56, previous key sizes=[]
-   ...
-   Cache miss due to new autograd node: MulBackward0 (NodeCall 2) with key size 71, previous key sizes=[]
-   ...
-   Cache miss due to new autograd node: DivBackward0 (NodeCall 2) with key size 70, previous key sizes=[]
-   ...
-   """
+.. image:: ../_static/img/compiled_autograd/recompile_due_to_node.png
 
 2. Due to tensors changing shapes:
 
@@ -286,16 +214,7 @@ In the example above, we call a different operator on each iteration, leading to
 
 In the example above, ``x`` changes shapes, and compiled autograd will mark ``x`` as a dynamic shape tensor after the first change. You should see recompiles messages: **Cache miss due to changed shapes**.
 
-.. code:: python
-
-   stderr_output = """
-   ...
-   Cache miss due to changed shapes: marking size idx 0 of torch::autograd::GraphRoot (NodeCall 0) as dynamic
-   Cache miss due to changed shapes: marking size idx 1 of torch::autograd::AccumulateGrad (NodeCall 2) as dynamic
-   Cache miss due to changed shapes: marking size idx 2 of torch::autograd::AccumulateGrad (NodeCall 2) as dynamic
-   Cache miss due to changed shapes: marking size idx 3 of torch::autograd::AccumulateGrad (NodeCall 2) as dynamic
-   ...
-   """
+.. image:: ../_static/img/compiled_autograd/recompile_due_to_dynamic.png
 
 Conclusion
 ----------
diff --git a/intermediate_source/ddp_tutorial.rst b/intermediate_source/ddp_tutorial.rst
index cff5105fa5..c91c195d6f 100644
--- a/intermediate_source/ddp_tutorial.rst
+++ b/intermediate_source/ddp_tutorial.rst
@@ -2,7 +2,7 @@ Getting Started with Distributed Data Parallel
 =================================================
 **Author**: `Shen Li <https://mrshenli.github.io/>`_
 
-**Edited by**: `Joe Zhu <https://github.com/gunandrose4u>`_
+**Edited by**: `Joe Zhu <https://github.com/gunandrose4u>`_, `Chirag Pandya <https://github.com/c-p-i-o>`__
 
 .. note::
    |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/ddp_tutorial.rst>`__.
@@ -15,24 +15,30 @@ Prerequisites:
 
 
 `DistributedDataParallel <https://pytorch.org/docs/stable/nn.html#module-torch.nn.parallel>`__
-(DDP) implements data parallelism at the module level which can run across
-multiple machines. Applications using DDP should spawn multiple processes and
-create a single DDP instance per process. DDP uses collective communications in the
+(DDP) is a powerful module in PyTorch that allows you to parallelize your model across
+multiple machines, making it perfect for large-scale deep learning applications.
+To use DDP, you'll need to spawn multiple processes and create a single instance of DDP per process.
+
+But how does it work? DDP uses collective communications from the
 `torch.distributed <https://pytorch.org/tutorials/intermediate/dist_tuto.html>`__
-package to synchronize gradients and buffers. More specifically, DDP registers
-an autograd hook for each parameter given by ``model.parameters()`` and the
-hook will fire when the corresponding gradient is computed in the backward
-pass. Then DDP uses that signal to trigger gradient synchronization across
-processes. Please refer to
-`DDP design note <https://pytorch.org/docs/master/notes/ddp.html>`__ for more details.
+package to synchronize gradients and buffers across all processes. This means that each process will have
+its own copy of the model, but they'll all work together to train the model as if it were on a single machine.
+
+To make this happen, DDP registers an autograd hook for each parameter in the model.
+When the backward pass is run, this hook fires and triggers gradient synchronization across all processes.
+This ensures that each process has the same gradients, which are then used to update the model.
+
+For more information on how DDP works and how to use it effectively, be sure to check out the
+`DDP design note <https://pytorch.org/docs/master/notes/ddp.html>`__.
+With DDP, you can train your models faster and more efficiently than ever before!
+
+The recommended way to use DDP is to spawn one process for each model replica. The model replica can span
+multiple devices. DDP processes can be placed on the same machine or across machines. Note that GPU devices
+cannot be shared across DDP processes (i.e. one GPU for one DDP process).
 
 
-The recommended way to use DDP is to spawn one process for each model replica,
-where a model replica can span multiple devices. DDP processes can be
-placed on the same machine or across machines, but GPU devices cannot be
-shared across processes. This tutorial starts from a basic DDP use case and
-then demonstrates more advanced use cases including checkpointing models and
-combining DDP with model parallel.
+In this tutorial, we'll start with a basic DDP use case and then demonstrate more advanced use cases,
+including checkpointing models and combining DDP with model parallel.
 
 
 .. note::
@@ -43,25 +49,22 @@ combining DDP with model parallel.
 Comparison between ``DataParallel`` and ``DistributedDataParallel``
 -------------------------------------------------------------------
 
-Before we dive in, let's clarify why, despite the added complexity, you would
-consider using ``DistributedDataParallel`` over ``DataParallel``:
+Before we dive in, let's clarify why you would consider using ``DistributedDataParallel``
+over ``DataParallel``, despite its added complexity:
 
-- First, ``DataParallel`` is single-process, multi-thread, and only works on a
-  single machine, while ``DistributedDataParallel`` is multi-process and works
-  for both single- and multi- machine training. ``DataParallel`` is usually
-  slower than ``DistributedDataParallel`` even on a single machine due to GIL
-  contention across threads, per-iteration replicated model, and additional
-  overhead introduced by scattering inputs and gathering outputs.
+- First, ``DataParallel`` is single-process, multi-threaded, but it only works on a
+  single machine. In contrast, ``DistributedDataParallel`` is multi-process and supports
+  both single- and multi- machine training.
+  Due to GIL contention across threads, per-iteration replicated model, and additional overhead introduced by
+  scattering inputs and gathering outputs, ``DataParallel`` is usually
+  slower than ``DistributedDataParallel`` even on a single machine.
 - Recall from the
   `prior tutorial <https://pytorch.org/tutorials/intermediate/model_parallel_tutorial.html>`__
   that if your model is too large to fit on a single GPU, you must use **model parallel**
   to split it across multiple GPUs. ``DistributedDataParallel`` works with
-  **model parallel**; ``DataParallel`` does not at this time. When DDP is combined
+  **model parallel**, while ``DataParallel`` does not at this time. When DDP is combined
   with model parallel, each DDP process would use model parallel, and all processes
   collectively would use data parallel.
-- If your model needs to span multiple machines or if your use case does not fit
-  into data parallelism paradigm, please see `the RPC API <https://pytorch.org/docs/stable/rpc.html>`__
-  for more generic distributed training support.
 
 Basic Use Case
 --------------
@@ -141,6 +144,7 @@ different DDP processes starting from different initial model parameter values.
         optimizer.step()
 
         cleanup()
+        print(f"Finished running basic DDP example on rank {rank}.")
 
 
     def run_demo(demo_fn, world_size):
@@ -154,7 +158,7 @@ provides a clean API as if it were a local model. Gradient synchronization
 communications take place during the backward pass and overlap with the
 backward computation. When the ``backward()`` returns, ``param.grad`` already
 contains the synchronized gradient tensor. For basic use cases, DDP only
-requires a few more LoCs to set up the process group. When applying DDP to more
+requires a few more lines of code to set up the process group. When applying DDP to more
 advanced use cases, some caveats require caution.
 
 Skewed Processing Speeds
@@ -179,13 +183,14 @@ It's common to use ``torch.save`` and ``torch.load`` to checkpoint modules
 during training and recover from checkpoints. See
 `SAVING AND LOADING MODELS <https://pytorch.org/tutorials/beginner/saving_loading_models.html>`__
 for more details. When using DDP, one optimization is to save the model in
-only one process and then load it to all processes, reducing write overhead.
-This is correct because all processes start from the same parameters and
+only one process and then load it on all processes, reducing write overhead.
+This works because all processes start from the same parameters and
 gradients are synchronized in backward passes, and hence optimizers should keep
-setting parameters to the same values. If you use this optimization, make sure no process starts 
+setting parameters to the same values.
+If you use this optimization (i.e. save on one process but restore on all), make sure no process starts
 loading before the saving is finished. Additionally, when
 loading the module, you need to provide an appropriate ``map_location``
-argument to prevent a process from stepping into others' devices. If ``map_location``
+argument to prevent processes from stepping into others' devices. If ``map_location``
 is missing, ``torch.load`` will first load the module to CPU and then copy each
 parameter to where it was saved, which would result in all processes on the
 same machine using the same set of devices. For more advanced failure recovery
@@ -218,7 +223,7 @@ and elasticity support, please refer to `TorchElastic <https://pytorch.org/elast
 
         loss_fn = nn.MSELoss()
         optimizer = optim.SGD(ddp_model.parameters(), lr=0.001)
-        
+
         optimizer.zero_grad()
         outputs = ddp_model(torch.randn(20, 10))
         labels = torch.randn(20, 5).to(rank)
@@ -234,6 +239,7 @@ and elasticity support, please refer to `TorchElastic <https://pytorch.org/elast
             os.remove(CHECKPOINT_PATH)
 
         cleanup()
+        print(f"Finished running DDP checkpoint example on rank {rank}.")
 
 Combining DDP with Model Parallelism
 ------------------------------------
@@ -285,6 +291,7 @@ either the application or the model ``forward()`` method.
         optimizer.step()
 
         cleanup()
+        print(f"Finished running DDP with model parallel example on rank {rank}.")
 
 
     if __name__ == "__main__":
@@ -323,15 +330,14 @@ Let's still use the Toymodel example and create a file named ``elastic_ddp.py``.
 
 
     def demo_basic():
+        torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
         dist.init_process_group("nccl")
         rank = dist.get_rank()
         print(f"Start running basic DDP example on rank {rank}.")
-   
         # create model and move it to GPU with id rank
         device_id = rank % torch.cuda.device_count()
         model = ToyModel().to(device_id)
         ddp_model = DDP(model, device_ids=[device_id])
-
         loss_fn = nn.MSELoss()
         optimizer = optim.SGD(ddp_model.parameters(), lr=0.001)
 
@@ -341,22 +347,23 @@ Let's still use the Toymodel example and create a file named ``elastic_ddp.py``.
         loss_fn(outputs, labels).backward()
         optimizer.step()
         dist.destroy_process_group()
-        
+        print(f"Finished running basic DDP example on rank {rank}.")
+
     if __name__ == "__main__":
         demo_basic()
 
-One can then run a `torch elastic/torchrun <https://pytorch.org/docs/stable/elastic/quickstart.html>`__ command 
+One can then run a `torch elastic/torchrun <https://pytorch.org/docs/stable/elastic/quickstart.html>`__ command
 on all nodes to initialize the DDP job created above:
 
 .. code:: bash
 
     torchrun --nnodes=2 --nproc_per_node=8 --rdzv_id=100 --rdzv_backend=c10d --rdzv_endpoint=$MASTER_ADDR:29400 elastic_ddp.py
 
-We are running the DDP script on two hosts, and each host we run with 8 processes, aka, we 
-are running it on 16 GPUs. Note that ``$MASTER_ADDR`` must be the same across all nodes.
+In the example above, we are running the DDP script on two hosts and we run with 8 processes on each host. That is,  we
+are running this job on 16 GPUs. Note that ``$MASTER_ADDR`` must be the same across all nodes.
 
-Here torchrun will launch 8 process and invoke ``elastic_ddp.py`` 
-on each process on the node it is launched on, but user also needs to apply cluster 
+Here ``torchrun`` will launch 8 processes and invoke ``elastic_ddp.py``
+on each process on the node it is launched on, but user also needs to apply cluster
 management tools like slurm to actually run this command on 2 nodes.
 
 For example, on a SLURM enabled cluster, we can write a script to run the command above
@@ -368,8 +375,8 @@ and set ``MASTER_ADDR`` as:
 
 
 Then we can just run this script using the SLURM command: ``srun --nodes=2 ./torchrun_script.sh``.
-Of course, this is just an example; you can choose your own cluster scheduling tools
-to initiate the torchrun job.
 
-For more information about Elastic run, one can check this 
-`quick start document <https://pytorch.org/docs/stable/elastic/quickstart.html>`__ to learn more.
+This is just an example; you can choose your own cluster scheduling tools to initiate the ``torchrun`` job.
+
+For more information about Elastic run, please see the
+`quick start document <https://pytorch.org/docs/stable/elastic/quickstart.html>`__.
diff --git a/intermediate_source/dist_pipeline_parallel_tutorial.rst b/intermediate_source/dist_pipeline_parallel_tutorial.rst
new file mode 100644
index 0000000000..ec3e3cf304
--- /dev/null
+++ b/intermediate_source/dist_pipeline_parallel_tutorial.rst
@@ -0,0 +1,10 @@
+Distributed Pipeline Parallelism Using RPC
+==========================================
+
+This tutorial has been deprecated.
+
+Redirecting to a newer tutorial in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/intermediate/pipelining_tutorial.html'" />
diff --git a/intermediate_source/dist_tuto.rst b/intermediate_source/dist_tuto.rst
index 4a45254998..c5ffc317c4 100644
--- a/intermediate_source/dist_tuto.rst
+++ b/intermediate_source/dist_tuto.rst
@@ -38,7 +38,7 @@ simultaneously. If you have access to compute cluster you should check
 with your local sysadmin or use your favorite coordination tool (e.g.,
 `pdsh <https://linux.die.net/man/1/pdsh>`__,
 `clustershell <https://cea-hpc.github.io/clustershell/>`__, or
-`others <https://slurm.schedmd.com/>`__). For the purpose of this
+`slurm <https://slurm.schedmd.com/>`__). For the purpose of this
 tutorial, we will use a single machine and spawn multiple processes using
 the following template.
 
@@ -64,11 +64,11 @@ the following template.
 
 
     if __name__ == "__main__":
-        size = 2
+        world_size = 2
         processes = []
         mp.set_start_method("spawn")
-        for rank in range(size):
-            p = mp.Process(target=init_process, args=(rank, size, run))
+        for rank in range(world_size):
+            p = mp.Process(target=init_process, args=(rank, world_size, run))
             p.start()
             processes.append(p)
 
@@ -125,7 +125,7 @@ process 0 increments the tensor and sends it to process 1 so that they
 both end up with 1.0. Notice that process 1 needs to allocate memory in
 order to store the data it will receive.
 
-Also notice that ``send``/``recv`` are **blocking**: both processes stop
+Also notice that ``send/recv`` are **blocking**: both processes block
 until the communication is completed. On the other hand immediates are
 **non-blocking**; the script continues its execution and the methods
 return a ``Work`` object upon which we can choose to
@@ -219,16 +219,23 @@ to obtain the sum of all tensors on all processes, we can use the
 Since we want the sum of all tensors in the group, we use
 ``dist.ReduceOp.SUM`` as the reduce operator. Generally speaking, any
 commutative mathematical operation can be used as an operator.
-Out-of-the-box, PyTorch comes with 4 such operators, all working at the
+Out-of-the-box, PyTorch comes with many such operators, all working at the
 element-wise level:
 
 -  ``dist.ReduceOp.SUM``,
 -  ``dist.ReduceOp.PRODUCT``,
 -  ``dist.ReduceOp.MAX``,
--  ``dist.ReduceOp.MIN``.
+-  ``dist.ReduceOp.MIN``,
+-  ``dist.ReduceOp.BAND``,
+-  ``dist.ReduceOp.BOR``,
+-  ``dist.ReduceOp.BXOR``,
+-  ``dist.ReduceOp.PREMUL_SUM``.
 
-In addition to ``dist.all_reduce(tensor, op, group)``, there are a total
-of 6 collectives currently implemented in PyTorch.
+The full list of supported operators is
+`here <https://pytorch.org/docs/stable/distributed.html#torch.distributed.ReduceOp>`__.
+
+In addition to ``dist.all_reduce(tensor, op, group)``, there are many additional collectives currently implemented in
+PyTorch. Here are a few supported collectives.
 
 -  ``dist.broadcast(tensor, src, group)``: Copies ``tensor`` from
    ``src`` to all other processes.
@@ -244,6 +251,12 @@ of 6 collectives currently implemented in PyTorch.
 -  ``dist.all_gather(tensor_list, tensor, group)``: Copies ``tensor``
    from all processes to ``tensor_list``, on all processes.
 -  ``dist.barrier(group)``: Blocks all processes in `group` until each one has entered this function.
+-  ``dist.all_to_all(output_tensor_list, input_tensor_list, group)``: Scatters list of input tensors to all processes in
+a group and return gathered list of tensors in output list.
+
+The full list of supported collectives can be found by looking at the latest documentation for PyTorch Distributed
+`(link) <https://pytorch.org/docs/stable/distributed.html>`__.
+
 
 Distributed Training
 --------------------
@@ -275,7 +288,7 @@ gradients of their model on their batch of data and then average their
 gradients. In order to ensure similar convergence results when changing
 the number of processes, we will first have to partition our dataset.
 (You could also use
-`tnt.dataset.SplitDataset <https://github.com/pytorch/tnt/blob/master/torchnet/dataset/splitdataset.py#L4>`__,
+`torch.utils.data.random_split <https://pytorch.org/docs/stable/data.html#torch.utils.data.random_split>`__,
 instead of the snippet below.)
 
 .. code:: python
@@ -389,7 +402,7 @@ could train any model on a large computer cluster.
 lot more tricks <https://seba-1511.github.io/dist_blog>`__ required to
 implement a production-level implementation of synchronous SGD. Again,
 use what `has been tested and
-optimized <https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel>`__.
+optimized <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel>`__.
 
 Our Own Ring-Allreduce
 ~~~~~~~~~~~~~~~~~~~~~~
@@ -451,8 +464,9 @@ Communication Backends
 
 One of the most elegant aspects of ``torch.distributed`` is its ability
 to abstract and build on top of different backends. As mentioned before,
-there are currently three backends implemented in PyTorch: Gloo, NCCL, and
-MPI. They each have different specifications and tradeoffs, depending
+there are multiple backends implemented in PyTorch.
+Some of the most popular ones are Gloo, NCCL, and MPI.
+They each have different specifications and tradeoffs, depending
 on the desired use case. A comparative table of supported functions can
 be found
 `here <https://pytorch.org/docs/stable/distributed.html#module-torch.distributed>`__.
@@ -544,15 +558,15 @@ NCCL backend is included in the pre-built binaries with CUDA support.
 Initialization Methods
 ~~~~~~~~~~~~~~~~~~~~~~
 
-To finish this tutorial, let's talk about the very first function we
-called: ``dist.init_process_group(backend, init_method)``. In
-particular, we will go over the different initialization methods which
-are responsible for the initial coordination step between each process.
-Those methods allow you to define how this coordination is done.
-Depending on your hardware setup, one of these methods should be
-naturally more suitable than the others. In addition to the following
-sections, you should also have a look at the `official
-documentation <https://pytorch.org/docs/stable/distributed.html#initialization>`__.
+To conclude this tutorial, let's examine the initial function we invoked:
+``dist.init_process_group(backend, init_method)``. Specifically, we will discuss the various
+initialization methods responsible for the preliminary coordination step between each process.
+These methods enable you to define how this coordination is accomplished.
+
+The choice of initialization method depends on your hardware setup, and one method may be more
+suitable than others. In addition to the following sections, please refer to the `official
+documentation <https://pytorch.org/docs/stable/distributed.html#initialization>`__ for further information.
+
 
 **Environment Variable**
 
diff --git a/intermediate_source/model_parallel_tutorial.py b/intermediate_source/model_parallel_tutorial.py
deleted file mode 100644
index 562064614b..0000000000
--- a/intermediate_source/model_parallel_tutorial.py
+++ /dev/null
@@ -1,357 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Single-Machine Model Parallel Best Practices
-============================================
-**Author**: `Shen Li <https://mrshenli.github.io/>`_
-
-Model parallel is widely-used in distributed training
-techniques. Previous posts have explained how to use
-`DataParallel <https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html>`_
-to train a neural network on multiple GPUs; this feature replicates the
-same model to all GPUs, where each GPU consumes a different partition of the
-input data. Although it can significantly accelerate the training process, it
-does not work for some use cases where the model is too large to fit into a
-single GPU. This post shows how to solve that problem by using **model parallel**,
-which, in contrast to ``DataParallel``, splits a single model onto different GPUs,
-rather than replicating the entire model on each GPU (to be concrete, say a model
-``m`` contains 10 layers: when using ``DataParallel``, each GPU will have a
-replica of each of these 10 layers, whereas when using model parallel on two GPUs,
-each GPU could host 5 layers).
-
-The high-level idea of model parallel is to place different sub-networks of a
-model onto different devices, and implement the ``forward`` method accordingly
-to move intermediate outputs across devices. As only part of a model operates
-on any individual device, a set of devices can collectively serve a larger
-model. In this post, we will not try to construct huge models and squeeze them
-into a limited number of GPUs. Instead, this post focuses on showing the idea
-of model parallel. It is up to the readers to apply the ideas to real-world
-applications.
-
-.. note::
-
-    For distributed model parallel training where a model spans multiple
-    servers, please refer to
-    `Getting Started With Distributed RPC Framework <rpc_tutorial.html>`__
-    for examples and details.
-
-Basic Usage
------------
-"""
-
-######################################################################
-# Let us start with a toy model that contains two linear layers. To run this
-# model on two GPUs, simply put each linear layer on a different GPU, and move
-# inputs and intermediate outputs to match the layer devices accordingly.
-#
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-class ToyModel(nn.Module):
-    def __init__(self):
-        super(ToyModel, self).__init__()
-        self.net1 = torch.nn.Linear(10, 10).to('cuda:0')
-        self.relu = torch.nn.ReLU()
-        self.net2 = torch.nn.Linear(10, 5).to('cuda:1')
-
-    def forward(self, x):
-        x = self.relu(self.net1(x.to('cuda:0')))
-        return self.net2(x.to('cuda:1'))
-
-######################################################################
-# Note that, the above ``ToyModel`` looks very similar to how one would
-# implement it on a single GPU, except the four ``to(device)`` calls which
-# place linear layers and tensors on proper devices. That is the only place in
-# the model that requires changes. The ``backward()`` and ``torch.optim`` will
-# automatically take care of gradients as if the model is on one GPU. You only
-# need to make sure that the labels are on the same device as the outputs when
-# calling the loss function.
-
-
-model = ToyModel()
-loss_fn = nn.MSELoss()
-optimizer = optim.SGD(model.parameters(), lr=0.001)
-
-optimizer.zero_grad()
-outputs = model(torch.randn(20, 10))
-labels = torch.randn(20, 5).to('cuda:1')
-loss_fn(outputs, labels).backward()
-optimizer.step()
-
-######################################################################
-# Apply Model Parallel to Existing Modules
-# ----------------------------------------
-#
-# It is also possible to run an existing single-GPU module on multiple GPUs
-# with just a few lines of changes. The code below shows how to decompose
-# ``torchvision.models.resnet50()`` to two GPUs. The idea is to inherit from
-# the existing ``ResNet`` module, and split the layers to two GPUs during
-# construction. Then, override the ``forward`` method to stitch two
-# sub-networks by moving the intermediate outputs accordingly.
-
-
-from torchvision.models.resnet import ResNet, Bottleneck
-
-num_classes = 1000
-
-
-class ModelParallelResNet50(ResNet):
-    def __init__(self, *args, **kwargs):
-        super(ModelParallelResNet50, self).__init__(
-            Bottleneck, [3, 4, 6, 3], num_classes=num_classes, *args, **kwargs)
-
-        self.seq1 = nn.Sequential(
-            self.conv1,
-            self.bn1,
-            self.relu,
-            self.maxpool,
-
-            self.layer1,
-            self.layer2
-        ).to('cuda:0')
-
-        self.seq2 = nn.Sequential(
-            self.layer3,
-            self.layer4,
-            self.avgpool,
-        ).to('cuda:1')
-
-        self.fc.to('cuda:1')
-
-    def forward(self, x):
-        x = self.seq2(self.seq1(x).to('cuda:1'))
-        return self.fc(x.view(x.size(0), -1))
-
-
-######################################################################
-# The above implementation solves the problem for cases where the model is too
-# large to fit into a single GPU. However, you might have already noticed that
-# it will be slower than running it on a single GPU if your model fits. It is
-# because, at any point in time, only one of the two GPUs are working, while
-# the other one is sitting there doing nothing. The performance further
-# deteriorates as the intermediate outputs need to be copied from ``cuda:0`` to
-# ``cuda:1`` between ``layer2`` and ``layer3``.
-#
-# Let us run an experiment to get a more quantitative view of the execution
-# time. In this experiment, we train ``ModelParallelResNet50`` and the existing
-# ``torchvision.models.resnet50()`` by running random inputs and labels through
-# them. After the training, the models will not produce any useful predictions,
-# but we can get a reasonable understanding of the execution times.
-
-
-import torchvision.models as models
-
-num_batches = 3
-batch_size = 120
-image_w = 128
-image_h = 128
-
-
-def train(model):
-    model.train(True)
-    loss_fn = nn.MSELoss()
-    optimizer = optim.SGD(model.parameters(), lr=0.001)
-
-    one_hot_indices = torch.LongTensor(batch_size) \
-                           .random_(0, num_classes) \
-                           .view(batch_size, 1)
-
-    for _ in range(num_batches):
-        # generate random inputs and labels
-        inputs = torch.randn(batch_size, 3, image_w, image_h)
-        labels = torch.zeros(batch_size, num_classes) \
-                      .scatter_(1, one_hot_indices, 1)
-
-        # run forward pass
-        optimizer.zero_grad()
-        outputs = model(inputs.to('cuda:0'))
-
-        # run backward pass
-        labels = labels.to(outputs.device)
-        loss_fn(outputs, labels).backward()
-        optimizer.step()
-
-
-######################################################################
-# The ``train(model)`` method above uses ``nn.MSELoss`` as the loss function,
-# and ``optim.SGD`` as the optimizer. It mimics training on ``128 X 128``
-# images which are organized into 3 batches where each batch contains 120
-# images. Then, we use ``timeit`` to run the ``train(model)`` method 10 times
-# and plot the execution times with standard deviations.
-
-
-import matplotlib.pyplot as plt
-plt.switch_backend('Agg')
-import numpy as np
-import timeit
-
-num_repeat = 10
-
-stmt = "train(model)"
-
-setup = "model = ModelParallelResNet50()"
-mp_run_times = timeit.repeat(
-    stmt, setup, number=1, repeat=num_repeat, globals=globals())
-mp_mean, mp_std = np.mean(mp_run_times), np.std(mp_run_times)
-
-setup = "import torchvision.models as models;" + \
-        "model = models.resnet50(num_classes=num_classes).to('cuda:0')"
-rn_run_times = timeit.repeat(
-    stmt, setup, number=1, repeat=num_repeat, globals=globals())
-rn_mean, rn_std = np.mean(rn_run_times), np.std(rn_run_times)
-
-
-def plot(means, stds, labels, fig_name):
-    fig, ax = plt.subplots()
-    ax.bar(np.arange(len(means)), means, yerr=stds,
-           align='center', alpha=0.5, ecolor='red', capsize=10, width=0.6)
-    ax.set_ylabel('ResNet50 Execution Time (Second)')
-    ax.set_xticks(np.arange(len(means)))
-    ax.set_xticklabels(labels)
-    ax.yaxis.grid(True)
-    plt.tight_layout()
-    plt.savefig(fig_name)
-    plt.close(fig)
-
-
-plot([mp_mean, rn_mean],
-     [mp_std, rn_std],
-     ['Model Parallel', 'Single GPU'],
-     'mp_vs_rn.png')
-
-
-######################################################################
-#
-# .. figure:: /_static/img/model-parallel-images/mp_vs_rn.png
-#    :alt:
-#
-# The result shows that the execution time of model parallel implementation is
-# ``4.02/3.75-1=7%`` longer than the existing single-GPU implementation. So we
-# can conclude there is roughly 7% overhead in copying tensors back and forth
-# across the GPUs. There are rooms for improvements, as we know one of the two
-# GPUs is sitting idle throughout the execution. One option is to further
-# divide each batch into a pipeline of splits, such that when one split reaches
-# the second sub-network, the following split can be fed into the first
-# sub-network. In this way, two consecutive splits can run concurrently on two
-# GPUs.
-
-######################################################################
-# Speed Up by Pipelining Inputs
-# -----------------------------
-#
-# In the following experiments, we further divide each 120-image batch into
-# 20-image splits. As PyTorch launches CUDA operations asynchronously, the
-# implementation does not need to spawn multiple threads to achieve
-# concurrency.
-
-
-class PipelineParallelResNet50(ModelParallelResNet50):
-    def __init__(self, split_size=20, *args, **kwargs):
-        super(PipelineParallelResNet50, self).__init__(*args, **kwargs)
-        self.split_size = split_size
-
-    def forward(self, x):
-        splits = iter(x.split(self.split_size, dim=0))
-        s_next = next(splits)
-        s_prev = self.seq1(s_next).to('cuda:1')
-        ret = []
-
-        for s_next in splits:
-            # A. ``s_prev`` runs on ``cuda:1``
-            s_prev = self.seq2(s_prev)
-            ret.append(self.fc(s_prev.view(s_prev.size(0), -1)))
-
-            # B. ``s_next`` runs on ``cuda:0``, which can run concurrently with A
-            s_prev = self.seq1(s_next).to('cuda:1')
-
-        s_prev = self.seq2(s_prev)
-        ret.append(self.fc(s_prev.view(s_prev.size(0), -1)))
-
-        return torch.cat(ret)
-
-
-setup = "model = PipelineParallelResNet50()"
-pp_run_times = timeit.repeat(
-    stmt, setup, number=1, repeat=num_repeat, globals=globals())
-pp_mean, pp_std = np.mean(pp_run_times), np.std(pp_run_times)
-
-plot([mp_mean, rn_mean, pp_mean],
-     [mp_std, rn_std, pp_std],
-     ['Model Parallel', 'Single GPU', 'Pipelining Model Parallel'],
-     'mp_vs_rn_vs_pp.png')
-
-######################################################################
-# Please note, device-to-device tensor copy operations are synchronized on
-# current streams on the source and the destination devices. If you create
-# multiple streams, you have to make sure that copy operations are properly
-# synchronized. Writing the source tensor or reading/writing the destination
-# tensor before finishing the copy operation can lead to undefined behavior.
-# The above implementation only uses default streams on both source and
-# destination devices, hence it is not necessary to enforce additional
-# synchronizations.
-#
-# .. figure:: /_static/img/model-parallel-images/mp_vs_rn_vs_pp.png
-#    :alt:
-#
-# The experiment result shows that, pipelining inputs to model parallel
-# ResNet50 speeds up the training process by roughly ``3.75/2.51-1=49%``. It is
-# still quite far away from the ideal 100% speedup. As we have introduced a new
-# parameter ``split_sizes`` in our pipeline parallel implementation, it is
-# unclear how the new parameter affects the overall training time. Intuitively
-# speaking, using small ``split_size`` leads to many tiny CUDA kernel launch,
-# while using large ``split_size`` results to relatively long idle times during
-# the first and last splits. Neither are optimal. There might be an optimal
-# ``split_size`` configuration for this specific experiment. Let us try to find
-# it by running experiments using several different ``split_size`` values.
-
-
-means = []
-stds = []
-split_sizes = [1, 3, 5, 8, 10, 12, 20, 40, 60]
-
-for split_size in split_sizes:
-    setup = "model = PipelineParallelResNet50(split_size=%d)" % split_size
-    pp_run_times = timeit.repeat(
-        stmt, setup, number=1, repeat=num_repeat, globals=globals())
-    means.append(np.mean(pp_run_times))
-    stds.append(np.std(pp_run_times))
-
-fig, ax = plt.subplots()
-ax.plot(split_sizes, means)
-ax.errorbar(split_sizes, means, yerr=stds, ecolor='red', fmt='ro')
-ax.set_ylabel('ResNet50 Execution Time (Second)')
-ax.set_xlabel('Pipeline Split Size')
-ax.set_xticks(split_sizes)
-ax.yaxis.grid(True)
-plt.tight_layout()
-plt.savefig("split_size_tradeoff.png")
-plt.close(fig)
-
-######################################################################
-#
-# .. figure:: /_static/img/model-parallel-images/split_size_tradeoff.png
-#    :alt:
-#
-# The result shows that setting ``split_size`` to 12 achieves the fastest
-# training speed, which leads to ``3.75/2.43-1=54%`` speedup. There are
-# still opportunities to further accelerate the training process. For example,
-# all operations on ``cuda:0`` is placed on its default stream. It means that
-# computations on the next split cannot overlap with the copy operation of the
-# ``prev`` split. However, as ``prev`` and next splits are different tensors, there is
-# no problem to overlap one's computation with the other one's copy. The
-# implementation need to use multiple streams on both GPUs, and different
-# sub-network structures require different stream management strategies. As no
-# general multi-stream solution works for all model parallel use cases, we will
-# not discuss it in this tutorial.
-#
-# **Note:**
-#
-# This post shows several performance measurements. You might see different
-# numbers when running the same code on your own machine, because the result
-# depends on the underlying hardware and software. To get the best performance
-# for your environment, a proper approach is to first generate the curve to
-# figure out the best split size, and then use that split size to pipeline
-# inputs.
-#
diff --git a/intermediate_source/model_parallel_tutorial.rst b/intermediate_source/model_parallel_tutorial.rst
new file mode 100644
index 0000000000..d687caf463
--- /dev/null
+++ b/intermediate_source/model_parallel_tutorial.rst
@@ -0,0 +1,10 @@
+Single-Machine Model Parallel Best Practices
+============================================
+
+This tutorial has been deprecated.
+
+Redirecting to latest parallelism APIs in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/dist_overview.html#parallelism-apis'" />
diff --git a/intermediate_source/nlp_from_scratch_index.rst b/intermediate_source/nlp_from_scratch_index.rst
new file mode 100644
index 0000000000..95f70746cb
--- /dev/null
+++ b/intermediate_source/nlp_from_scratch_index.rst
@@ -0,0 +1,48 @@
+NLP from Scratch
+================
+
+In these three-part series you will build and train
+a basic character-level Recurrent Neural Network (RNN) to classify words.
+
+You will learn:
+
+* How to construct Recurrent Neural Networks from scratch
+* Essential data handling techniques for NLP
+* How to train an RNN to identify the language origin of words.
+
+Before you begin, we recommend that you review the following:
+
+* `PyTorch Learn the Basics series <https://pytorch.org/tutorials/beginner/basics/intro.html>`__
+* `How to install PyTorch <https://pytorch.org/get-started/locally/>`__
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        NLP From Scratch - Part 1: Classifying Names with a Character-Level RNN
+        :link: https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html
+        :link-type: url
+
+        Learn how to use an RNN to classify names into their language of origin.
+        +++
+        :octicon:`code;1em` Code
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        NLP From Scratch - Part 2: Generating Names with a Character-Level RNN
+        :link: https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html
+        :link-type: url
+
+        Expand the RNN we created in Part 1 to generate names from languages.
+        +++
+        :octicon:`code;1em` Code
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        NLP From Scratch - Part 3: Translation with a Sequence to Sequence Network and Attention
+        :link: https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html
+        :link-type: url
+
+        Create a sequence-to-sequence model that can translate your text from French
+        to English.
+        +++
+        :octicon:`code;1em` Code
+
+
diff --git a/intermediate_source/pipeline_tutorial.rst b/intermediate_source/pipeline_tutorial.rst
new file mode 100644
index 0000000000..06f10a4a88
--- /dev/null
+++ b/intermediate_source/pipeline_tutorial.rst
@@ -0,0 +1,11 @@
+Training Transformer models using Pipeline Parallelism
+======================================================
+
+This tutorial has been deprecated.
+
+Redirecting to the latest parallelism APIs in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/intermediate/pipelining_tutorial.html'" />
+
diff --git a/intermediate_source/seq2seq_translation_tutorial.py b/intermediate_source/seq2seq_translation_tutorial.py
index c9e360d751..5de4bb4ca3 100755
--- a/intermediate_source/seq2seq_translation_tutorial.py
+++ b/intermediate_source/seq2seq_translation_tutorial.py
@@ -4,11 +4,15 @@
 *******************************************************************************
 **Author**: `Sean Robertson <https://github.com/spro>`_
 
-This is the third and final tutorial on doing "NLP From Scratch", where we
+This tutorials is part of a three-part series:
+
+* `NLP From Scratch: Classifying Names with a Character-Level RNN <https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html>`__
+* `NLP From Scratch: Generating Names with a Character-Level RNN <https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html>`__
+* `NLP From Scratch: Translation with a Sequence to Sequence Network and Attention <https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html>`__
+
+This is the third and final tutorial on doing **NLP From Scratch**, where we
 write our own classes and functions to preprocess the data to do our NLP
-modeling tasks. We hope after you complete this tutorial that you'll proceed to
-learn how `torchtext` can handle much of this preprocessing for you in the
-three tutorials immediately following this one.
+modeling tasks.
 
 In this project we will be teaching a neural network to translate from
 French to English.
diff --git a/intermediate_source/tensorboard_profiler_tutorial.py b/intermediate_source/tensorboard_profiler_tutorial.py
index 00bdcfbf07..3782ced18d 100644
--- a/intermediate_source/tensorboard_profiler_tutorial.py
+++ b/intermediate_source/tensorboard_profiler_tutorial.py
@@ -4,6 +4,14 @@
 This tutorial demonstrates how to use TensorBoard plugin with PyTorch Profiler
 to detect performance bottlenecks of the model.
 
+.. warning::
+   The TensorBoard integration with the PyTorch profiler is now
+   deprecated. Instead, use Perfetto or the Chrome trace to
+   view ``trace.json`` files. After
+   `generating a trace <https://pytorch.org/tutorials/recipes/recipes/profiler_recipe.html#using-tracing-functionality>`__,
+   simply drag the ``trace.json`` into `Perfetto UI <https://ui.perfetto.dev/>`__
+   or ``chrome://tracing`` to visualize your profile.
+
 Introduction
 ------------
 PyTorch 1.8 includes an updated profiler API capable of
diff --git a/intermediate_source/torchrec_tutorial.rst b/intermediate_source/torchrec_tutorial.rst
new file mode 100644
index 0000000000..883ca11087
--- /dev/null
+++ b/intermediate_source/torchrec_tutorial.rst
@@ -0,0 +1,10 @@
+Introduction to TorchRec
+========================
+
+There is a newer tutorial on this topic.
+
+Redirecting...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="0; url='https://pytorch.org/tutorials/intermediate/torchrec_intro_tutorial.html'" />
diff --git a/prototype_source/inductor_windows_cpu.rst b/prototype_source/inductor_windows_cpu.rst
index 801ebe060e..96e1bf4690 100644
--- a/prototype_source/inductor_windows_cpu.rst
+++ b/prototype_source/inductor_windows_cpu.rst
@@ -115,6 +115,8 @@ Intel Compiler
 #. Download and install `Intel Compiler <https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler-download.html>`_ with Windows version.
 #. Set Windows Inductor Compiler with the CXX environment variable ``set CXX=icx-cl``.
 
+Intel also provides a comprehensive step-by-step guide, complete with performance data. Please check `Intel® oneAPI DPC++/C++ Compiler Boosts PyTorch* Inductor Performance on Windows* for CPU Devices <https://www.intel.com/content/www/us/en/developer/articles/technical/boost-pytorch-inductor-performance-on-windows.html>`_.
+
 LLVM Compiler
 ^^^^^^^^^^^^^
 
diff --git a/prototype_source/ios_coreml_workflow.rst b/prototype_source/ios_coreml_workflow.rst
index bfaccd77a1..db9abcc507 100644
--- a/prototype_source/ios_coreml_workflow.rst
+++ b/prototype_source/ios_coreml_workflow.rst
@@ -1,128 +1,10 @@
 (Prototype) Convert Mobilenetv2 to Core ML
 ==========================================
 
-**Author**: `Tao Xu <https://github.com/xta0>`_
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-Introduction
-------------
+Redirecting in 3 seconds...
 
-Core ML provides access to powerful and efficient NPUs(Neural Process Unit) on modern iPhone devices. This tutorial shows how to prepare a computer vision model (mobilenetv2) to use the PyTorch Core ML mobile backend. 
+.. raw:: html
 
-Note that this feature is currently in the “prototype” phase and only supports a limited numbers of operators, but we expect to solidify the integration and expand our operator support over time. The APIs are subject to change in the future.
-
-Environment Setup (MacOS)
--------------------------
-
-Let's start off by creating a new conda environment.
-
-.. code:: shell
-
-    conda create --name 1.10 python=3.8 --yes
-    conda activate 1.10
-
-Next, since the Core ML delegate is a prototype feature, let's install the PyTorch nightly build and coremltools
-
-.. code:: shell
-
-    pip3 install --pre torch torchvision torchaudio -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html
-
-    pip3 install coremltools==5.0b5 protobuf==3.20.1
-
-
-Model Preparation
--------------------
-
-To convert a pre-trained mobilenetv2 model to be Core ML compatible, we're going to use the ``to_backend()`` API, which is a prototype feature for delegating model executions to some specific backends. The following python code shows how to use it to convert the mobilenetv2 torchscript model.
-
-.. code:: python
-
-    import torch
-    import torchvision
-
-    from torch.backends._coreml.preprocess import (
-        CompileSpec,
-        TensorSpec,
-        CoreMLComputeUnit,
-    )
-
-    def mobilenetv2_spec():
-        return {
-            "forward": CompileSpec(
-                inputs=(
-                    TensorSpec(
-                        shape=[1, 3, 224, 224],
-                    ),
-                ),
-                outputs=(
-                    TensorSpec(
-                        shape=[1, 1000],
-                    ),
-                ),
-                backend=CoreMLComputeUnit.ALL,
-                allow_low_precision=True,
-            ),
-        }
-
-
-    def main():
-        model = torchvision.models.mobilenet_v2(pretrained=True)
-        model.eval()
-        example = torch.rand(1, 3, 224, 224)
-        model = torch.jit.trace(model, example)
-        compile_spec = mobilenetv2_spec()
-        mlmodel = torch._C._jit_to_backend("coreml", model, compile_spec)
-        mlmodel._save_for_lite_interpreter("./mobilenetv2_coreml.ptl")
-
-
-    if __name__ == "__main__":
-        main()
-
-
-First, we need to call ``.eval()`` to set the model to inference mode. Secondly, we defined a ``mobilenetv2_spec()`` function to tell Core ML what the model looks like. Note that the ``CoreMLComputeUnit`` corresponds to `Apple's processing unit <https://developer.apple.com/documentation/coreml/mlcomputeunits>`_ whose value can be ``CPU``, ``CPUAndGPU`` and ``ALL``. In our example, we set the ``backend`` type to ``ALL`` which means Core ML will try to run the model on Neural Engine. Finally, we called the ``to_backend`` API to convert the torchscript model to a Core ML compatible model and save it to the disk.
-
-Run the python script. If everything works well, you should see following outputs from coremltools
-
-.. code:: shell
-
-    Converting Frontend ==> MIL Ops: 100%|███████████████████████████████████████████████████████████████████████████████▊| 384/385 [00:00<00:00, 1496.98 ops/s]
-    Running MIL Common passes:   0%|
-    0/33 [00:00<?, ? passes/s]/Users/distill/anaconda3/envs/1.10/lib/python3.8/site-packages/coremltools/converters/mil/mil/passes/name_sanitization_utils.py:129: UserWarning: Output, '647', of the source model, has been renamed to 'var_647' in the Core ML model.
-    warnings.warn(msg.format(var.name, new_name))
-    Running MIL Common passes: 100%|███████████████████████████████████████████████████████████████████████████████████████| 33/33 [00:00<00:00, 84.16 passes/s]
-    Running MIL Clean up passes: 100%|██████████████████████████████████████████████████████████████████████████████████████| 8/8 [00:00<00:00, 138.17 passes/s]
-    Translating MIL ==> NeuralNetwork Ops: 100%|██████████████████████████████████████████████████████████████████████████| 495/495 [00:00<00:00, 1977.15 ops/s]
-    [W backend_detail.cpp:376] Warning: Backend [coreml] is not available. Execution of this Module is still possible by saving and loading on a device where the backend is available. (function codegen_backend_module)
-
-We can safely ignore the warning above, as we don't plan to run our model on desktop.
-
-iOS app integration
----------------------
-
-Now that the model is ready, we can integrate it to our app. We'll be using the pytorch nightly cocoapods which contains the code for executing the Core ML model. Simply add the following code to your Podfile
-
-.. code:: shell
-
-    pod LibTorch-Lite-Nightly
-
-In this tutorial, we'll be reusing our `HelloWorld <https://github.com/pytorch/ios-demo-app/tree/master/HelloWorld-CoreML>`_ project. Feel free to walk through the code there.
-
-To benchmark the latency, you can simply put the following code before and after the PyTorch ``forward`` function
-
-.. code:: objective-c
-
-    caffe2::Timer t;
-    auto outputTensor = _impl.forward({tensor}).toTensor().cpu();
-    std::cout << "forward took: " << t.MilliSeconds() << std::endl;
-
-Conclusion
-----------
-
-In this tutorial, we demonstrated how to convert a mobilenetv2 model to a Core ML compatible model. Please be aware of that Core ML feature is still under development, new operators/models will continue to be added. APIs are subject to change in the future versions.
-
-Thanks for reading! As always, we welcome any feedback, so please create an issue `here <https://github.com/pytorch/pytorch/issues>`_ if you have any.
-
-Learn More
-----------
-
-- The `Mobilenetv2 <https://pytorch.org/hub/pytorch_vision_mobilenet_v2/>`_ from Torchvision
-- Information about `Core ML <https://developer.apple.com/documentation/coreml>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/prototype_source/ios_gpu_workflow.rst b/prototype_source/ios_gpu_workflow.rst
index cb7a0034b2..8915e1c4fa 100644
--- a/prototype_source/ios_gpu_workflow.rst
+++ b/prototype_source/ios_gpu_workflow.rst
@@ -1,142 +1,10 @@
 (Prototype) Use iOS GPU in PyTorch
 ==================================
 
-**Author**: `Tao Xu <https://github.com/xta0>`_
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-Introduction
-------------
+Redirecting in 3 seconds...
 
-This tutorial introduces the steps to run your models on iOS GPU. We'll be using the mobilenetv2 model as an example. Since the mobile GPU features are currently in the prototype stage, you'll need to build a custom pytorch binary from source. For the time being, only a limited number of operators are supported, and certain client side APIs are subject to change in the future versions.
+.. raw:: html
 
-Model Preparation
--------------------
-
-Since GPUs consume weights in a different order, the first step we need to do is to convert our TorchScript model to a GPU compatible model. This step is also known as "prepacking".
-
-PyTorch with Metal
-^^^^^^^^^^^^^^^^^^
-To do that, we'll install a pytorch nightly binary that includes the Metal backend. Go ahead run the command below
-
-.. code:: shell
-
-    conda install pytorch -c pytorch-nightly
-    // or
-    pip3 install --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html
-
-Also, you can build a custom pytorch binary from source that includes the Metal backend. Just checkout the pytorch source code from github and run the command below
-
-.. code:: shell
-
-    cd PYTORCH_ROOT
-    USE_PYTORCH_METAL_EXPORT=ON python setup.py install --cmake
-
-The command above will build a custom pytorch binary from master. The ``install`` argument simply tells ``setup.py`` to override the existing PyTorch on your desktop. Once the build finished, open another terminal to check the PyTorch version to see if the installation was successful. As the time of writing of this recipe, the version is ``1.8.0a0+41237a4``. You might be seeing different numbers depending on when you check out the code from master, but it should be greater than 1.7.0.
-
-.. code:: python
-
-    import torch
-    torch.__version__ #1.8.0a0+41237a4
-
-Metal Compatible Model
-^^^^^^^^^^^^^^^^^^^^^^
-
-The next step is going to be converting the mobilenetv2 torchscript model to a Metal compatible model. We'll be leveraging the ``optimize_for_mobile`` API from the ``torch.utils`` module. As shown below
-
-.. code:: python
-
-    import torch
-    import torchvision
-    from torch.utils.mobile_optimizer import optimize_for_mobile
-
-    model = torchvision.models.mobilenet_v2(pretrained=True)
-    scripted_model = torch.jit.script(model)
-    optimized_model = optimize_for_mobile(scripted_model, backend='metal')
-    print(torch.jit.export_opnames(optimized_model))
-    optimized_model._save_for_lite_interpreter('./mobilenetv2_metal.pt')
-
-Note that the ``torch.jit.export_opnames(optimized_model)`` is going to dump all the optimized operators from the ``optimized_mobile``. If everything works well, you should be able to see the following ops being printed out from the console
-
-
-.. code:: shell
-
-    ['aten::adaptive_avg_pool2d',
-    'aten::add.Tensor',
-    'aten::addmm',
-    'aten::reshape',
-    'aten::size.int',
-    'metal::copy_to_host',
-    'metal_prepack::conv2d_run']
-
-Those are all the ops we need to run the mobilenetv2 model on iOS GPU. Cool! Now that you have the ``mobilenetv2_metal.pt`` saved on your disk, let's move on to the iOS part.
-
-
-Use PyTorch iOS library with Metal
-----------------------------------
-The PyTorch iOS library with Metal support ``LibTorch-Lite-Nightly`` is available in Cocoapods. You can read the `Using the Nightly PyTorch iOS Libraries in CocoaPods <https://pytorch.org/mobile/ios/#using-the-nightly-pytorch-ios-libraries-in-cocoapods>`_ section from the iOS tutorial for more detail about its usage. 
-
-We also have the `HelloWorld-Metal example <https://github.com/pytorch/ios-demo-app/tree/master/HelloWorld-Metal>`_ that shows how to conect all pieces together.  
-
-Note that if you run the HelloWorld-Metal example, you may notice that the results are slighly different from the `results <https://pytorch.org/mobile/ios/#install-libtorch-via-cocoapods>`_ we got from the CPU model as shown in the iOS tutorial.
-
-.. code:: shell
-
-    - timber wolf, grey wolf, gray wolf, Canis lupus
-    - malamute, malemute, Alaskan malamute
-    - Eskimo dog, husky
-
-This is because by default Metal uses fp16 rather than fp32 to compute. The precision loss is expected. 
-
-
-Use LibTorch-Lite Built from Source
------------------------------------
-
-You can also build a custom LibTorch-Lite from Source and use it to run GPU models on iOS Metal. In this section, we'll be using the `HelloWorld example <https://github.com/pytorch/ios-demo-app/tree/master/HelloWorld>`_ to demonstrate this process. 
-
-First, make sure you have deleted the **build** folder from the "Model Preparation" step in PyTorch root directory. Then run the command below
-
-.. code:: shell
-
-    IOS_ARCH=arm64 USE_PYTORCH_METAL=1 ./scripts/build_ios.sh
-
-Note ``IOS_ARCH`` tells the script to build a arm64 version of Libtorch-Lite. This is because in PyTorch, Metal is only available for the iOS devices that support the Apple A9 chip or above. Once the build finished, follow the `Build PyTorch iOS libraries from source <https://pytorch.org/mobile/ios/#build-pytorch-ios-libraries-from-source>`_ section from the iOS tutorial to setup the XCode settings properly. Don't forget to copy the ``./mobilenetv2_metal.pt`` to your XCode project and modify the model file path accordingly.
-
-Next we need to make some changes in ``TorchModule.mm``
-
-.. code:: objective-c
-
-    ...
-    // #import <Libtorch-Lite/Libtorch-Lite.h>
-    // If it's built from source with Xcode, comment out the line above
-    // and use following headers
-    #include <torch/csrc/jit/mobile/import.h>
-    #include <torch/csrc/jit/mobile/module.h>
-    #include <torch/script.h>
-    ...
-
-    - (NSArray<NSNumber*>*)predictImage:(void*)imageBuffer {
-      c10::InferenceMode mode;
-      at::Tensor tensor = torch::from_blob(imageBuffer, {1, 3, 224, 224}, at::kFloat).metal();
-      auto outputTensor = _impl.forward({tensor}).toTensor().cpu();
-      ...
-    }
-    ...
-
-As you can see, we simply just call ``.metal()`` to move our input tensor from CPU to GPU, and then call ``.cpu()`` to move the result back. Internally, ``.metal()`` will copy the input data from the CPU buffer to a GPU buffer with a GPU compatible memory format. When ``.cpu()`` is invoked, the GPU command buffer will be flushed and synced. After `forward` finished, the final result will then be copied back from the GPU buffer back to a CPU buffer.
-
-The last step we have to do is to add the ``Accelerate.framework`` and the ``MetalPerformanceShaders.framework`` to your xcode project (Open your project via XCode, go to your project target’s "General" tab, locate the "Frameworks, Libraries and Embedded Content" section and click the "+" button).
-
-If everything works fine, you should be able to see the inference results on your phone. 
-
-
-Conclusion
-----------
-
-In this tutorial, we demonstrated how to convert a mobilenetv2 model to a GPU compatible model. We walked through a HelloWorld example to show how to use the C++ APIs to run models on iOS GPU. Please be aware of that GPU feature is still under development, new operators will continue to be added. APIs are subject to change in the future versions.
-
-Thanks for reading! As always, we welcome any feedback, so please create an issue `here <https://github.com/pytorch/pytorch/issues>`_ if you have any.
-
-Learn More
-----------
-
-- The `Mobilenetv2 <https://pytorch.org/hub/pytorch_vision_mobilenet_v2/>`_ from Torchvision
-- To learn more about how to use ``optimize_for_mobile``, please refer to the `Mobile Perf Recipe <https://pytorch.org/tutorials/recipes/mobile_perf.html>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/prototype_source/nnapi_mobilenetv2.rst b/prototype_source/nnapi_mobilenetv2.rst
index ed9548a387..ef7edc92d1 100644
--- a/prototype_source/nnapi_mobilenetv2.rst
+++ b/prototype_source/nnapi_mobilenetv2.rst
@@ -1,218 +1,10 @@
 (Beta) Convert MobileNetV2 to NNAPI
 ========================================
 
-Introduction
-------------
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-This tutorial shows how to prepare a computer vision model to use
-`Android's Neural Networks API (NNAPI) <https://developer.android.com/ndk/guides/neuralnetworks>`_.
-NNAPI provides access to powerful and efficient computational cores
-on many modern Android devices.
+Redirecting in 3 seconds...
 
-PyTorch's NNAPI is currently in the "prototype" phase and only supports
-a limited range of operators, but we expect to solidify the integration
-and expand our operator support over time.
+.. raw:: html
 
-
-Environment
------------
-
-Install PyTorch and torchvision.
-
-``pip install torch==1.10.0 torchvision==0.11.1``
-
-
-Model Preparation
------------------
-
-First, we must prepare our model to execute with NNAPI.
-This step runs on your training server or laptop.
-The key conversion function to call is
-``torch.backends._nnapi.prepare.convert_model_to_nnapi``,
-but some extra steps are required to ensure that
-the model is properly structured.
-Most notably, quantizing the model is required
-in order to run the model on certain accelerators.
-
-You can copy/paste this entire Python script and run it,
-or make your own modifications.
-By default, it will save the models to ``~/mobilenetv2-nnapi/``.
-Please create that directory first.
-
-.. code:: python
-
-    #!/usr/bin/env python
-    import sys
-    import os
-    import torch
-    import torch.utils.bundled_inputs
-    import torch.utils.mobile_optimizer
-    import torch.backends._nnapi.prepare
-    import torchvision.models.quantization.mobilenet
-    from pathlib import Path
-
-
-    # This script supports 3 modes of quantization:
-    # - "none": Fully floating-point model.
-    # - "core": Quantize the core of the model, but wrap it a
-    #    quantizer/dequantizer pair, so the interface uses floating point.
-    # - "full": Quantize the model, and use quantized tensors
-    #   for input and output.
-    #
-    # "none" maintains maximum accuracy
-    # "core" sacrifices some accuracy for performance,
-    # but maintains the same interface.
-    # "full" maximized performance (with the same accuracy as "core"),
-    # but requires the application to use quantized tensors.
-    #
-    # There is a fourth option, not supported by this script,
-    # where we include the quant/dequant steps as NNAPI operators.
-    def make_mobilenetv2_nnapi(output_dir_path, quantize_mode):
-        quantize_core, quantize_iface = {
-            "none": (False, False),
-            "core": (True, False),
-            "full": (True, True),
-        }[quantize_mode]
-
-        model = torchvision.models.quantization.mobilenet.mobilenet_v2(pretrained=True, quantize=quantize_core)
-        model.eval()
-
-        # Fuse BatchNorm operators in the floating point model.
-        # (Quantized models already have this done.)
-        # Remove dropout for this inference-only use case.
-        if not quantize_core:
-            model.fuse_model()
-        assert type(model.classifier[0]) == torch.nn.Dropout
-        model.classifier[0] = torch.nn.Identity()
-
-        input_float = torch.zeros(1, 3, 224, 224)
-        input_tensor = input_float
-
-        # If we're doing a quantized model, we need to trace only the quantized core.
-        # So capture the quantizer and dequantizer, use them to prepare the input,
-        # and replace them with identity modules so we can trace without them.
-        if quantize_core:
-            quantizer = model.quant
-            dequantizer = model.dequant
-            model.quant = torch.nn.Identity()
-            model.dequant = torch.nn.Identity()
-            input_tensor = quantizer(input_float)
-
-        # Many NNAPI backends prefer NHWC tensors, so convert our input to channels_last,
-        # and set the "nnapi_nhwc" attribute for the converter.
-        input_tensor = input_tensor.contiguous(memory_format=torch.channels_last)
-        input_tensor.nnapi_nhwc = True
-
-        # Trace the model.  NNAPI conversion only works with TorchScript models,
-        # and traced models are more likely to convert successfully than scripted.
-        with torch.no_grad():
-            traced = torch.jit.trace(model, input_tensor)
-        nnapi_model = torch.backends._nnapi.prepare.convert_model_to_nnapi(traced, input_tensor)
-
-        # If we're not using a quantized interface, wrap a quant/dequant around the core.
-        if quantize_core and not quantize_iface:
-            nnapi_model = torch.nn.Sequential(quantizer, nnapi_model, dequantizer)
-            model.quant = quantizer
-            model.dequant = dequantizer
-            # Switch back to float input for benchmarking.
-            input_tensor = input_float.contiguous(memory_format=torch.channels_last)
-
-        # Optimize the CPU model to make CPU-vs-NNAPI benchmarks fair.
-        model = torch.utils.mobile_optimizer.optimize_for_mobile(torch.jit.script(model))
-
-        # Bundle sample inputs with the models for easier benchmarking.
-        # This step is optional.
-        class BundleWrapper(torch.nn.Module):
-            def __init__(self, mod):
-                super().__init__()
-                self.mod = mod
-            def forward(self, arg):
-                return self.mod(arg)
-        nnapi_model = torch.jit.script(BundleWrapper(nnapi_model))
-        torch.utils.bundled_inputs.augment_model_with_bundled_inputs(
-            model, [(torch.utils.bundled_inputs.bundle_large_tensor(input_tensor),)])
-        torch.utils.bundled_inputs.augment_model_with_bundled_inputs(
-            nnapi_model, [(torch.utils.bundled_inputs.bundle_large_tensor(input_tensor),)])
-
-        # Save both models.
-        model._save_for_lite_interpreter(str(output_dir_path / ("mobilenetv2-quant_{}-cpu.pt".format(quantize_mode))))
-        nnapi_model._save_for_lite_interpreter(str(output_dir_path / ("mobilenetv2-quant_{}-nnapi.pt".format(quantize_mode))))
-
-
-    if __name__ == "__main__":
-        for quantize_mode in ["none", "core", "full"]:
-            make_mobilenetv2_nnapi(Path(os.environ["HOME"]) / "mobilenetv2-nnapi", quantize_mode)
-
-
-Running Benchmarks
-------------------
-
-Now that the models are ready, we can benchmark them on our Android devices.
-See `our performance recipe <https://pytorch.org/tutorials/recipes/mobile_perf.html#android-benchmarking-setup>`_ for details.
-The best-performing models are likely to be the "fully-quantized" models:
-``mobilenetv2-quant_full-cpu.pt`` and ``mobilenetv2-quant_full-nnapi.pt``.
-
-Because these models have bundled inputs, we can run the benchmark as follows:
-
-.. code:: shell
-
-   ./speed_benchmark_torch --pthreadpool_size=1 --model=mobilenetv2-quant_full-nnapi.pt --use_bundled_input=0 --warmup=5 --iter=200
-
-Adjusting increasing the thread pool size can can reduce latency,
-at the cost of increased CPU usage.
-Omitting that argument will use one thread per big core.
-The CPU models can get improved performance (at the cost of memory usage)
-by passing ``--use_caching_allocator=true``.
-
-
-Running model on host
----------------------
-
-We can now run models on your linux machine using the reference implementation
-of NNAPI. You need to build the NNAPI library from Android source code:
-
-* Make sure you have at least 200GB of disk space
-* Follow `these instructions <https://source.android.com/setup/develop#installing-repo>`_ to install ``repo`` 
-
-.. code:: shell
-
-    mkdir ~/android-nnapi && cd ~/android-nnapi
-    repo init -u https://android.googlesource.com/platform/manifest -b master
-    repo sync --network-only -j 16
-    repo sync -l
-    . build/envsetup.sh
-    lunch aosp_x86_64-eng
-    mm -j16 out/host/linux-x86/lib64/libneuralnetworks.so
-
-
-With the host build of ``libneuralnetworks.so`` you can run Pytorch NNAPI models on
-your linux machine:
-
-.. code:: python
-
-    #!/usr/bin/env python
-    import ctypes
-    import torch
-    from pathlib import Path
-
-    ctypes.cdll.LoadLibrary(Path.home() / "android-nnapi/out/host/linux-x86/lib64/libneuralnetworks.so")
-    model = torch.jit.load(Path.home() / "mobilenetv2-nnapi/mobilenetv2-quant_full-nnapi.pt")
-    print(model(*model.get_all_bundled_inputs()[0]))
-
-
-Integration
------------
-
-The converted models are ordinary TorchScript models.
-You can use them in your app just like any other PyTorch model.
-See `https://pytorch.org/mobile/android/ <https://pytorch.org/mobile/android/>`_
-for an introduction to using PyTorch on Android.
-
-
-Learn More
-----------
-
-- Learn more about optimization in our
-  `Mobile Performance Recipe <https://pytorch.org/tutorials/recipes/mobile_perf.html>`_
-- `MobileNetV2 <https://pytorch.org/hub/pytorch_vision_mobilenet_v2/>`_ from torchvision
-- Information about `NNAPI <https://developer.android.com/ndk/guides/neuralnetworks>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/prototype_source/pt2e_quant_ptq.rst b/prototype_source/pt2e_quant_ptq.rst
index 0fe713f8ab..4873bce7d5 100644
--- a/prototype_source/pt2e_quant_ptq.rst
+++ b/prototype_source/pt2e_quant_ptq.rst
@@ -51,7 +51,6 @@ The PyTorch 2 export quantization API looks like this:
 .. code:: python
 
   import torch
-  from torch._export import capture_pre_autograd_graph
   class M(torch.nn.Module):
      def __init__(self):
         super().__init__()
@@ -65,9 +64,9 @@ The PyTorch 2 export quantization API looks like this:
   m = M().eval()
 
   # Step 1. program capture
-  # NOTE: this API will be updated to torch.export API in the future, but the captured
-  # result shoud mostly stay the same
-  m = capture_pre_autograd_graph(m, *example_inputs)
+  # This is available for pytorch 2.5+, for more details on lower pytorch versions
+  # please check `Export the model with torch.export` section
+  m = torch.export.export_for_training(m, example_inputs).module()
   # we get a model with aten ops
 
 
@@ -77,7 +76,7 @@ The PyTorch 2 export quantization API looks like this:
     convert_pt2e,
   )
 
-  from torch.ao.quantization.quantizer import (
+  from torch.ao.quantization.quantizer.xnnpack_quantizer import (
     XNNPACKQuantizer,
     get_symmetric_quantization_config,
   )
@@ -280,10 +279,7 @@ and rename it to ``data/resnet18_pretrained_float.pth``.
         return model
 
     def print_size_of_model(model):
-        if isinstance(model, torch.jit.RecursiveScriptModule):
-            torch.jit.save(model, "temp.p")
-        else:
-            torch.jit.save(torch.jit.script(model), "temp.p")
+        torch.save(model.state_dict(), "temp.p")
         print("Size (MB):", os.path.getsize("temp.p")/1e6)
         os.remove("temp.p")
 
@@ -351,18 +347,28 @@ Here is how you can use ``torch.export`` to export the model:
 
 .. code-block:: python
 
-    from torch._export import capture_pre_autograd_graph
-
     example_inputs = (torch.rand(2, 3, 224, 224),)
-    exported_model = capture_pre_autograd_graph(model_to_quantize, example_inputs)
+    # for pytorch 2.5+
+    exported_model = torch.export.export_for_training(model_to_quantize, example_inputs).module()
+
+    # for pytorch 2.4 and before
+    # from torch._export import capture_pre_autograd_graph
+    # exported_model = capture_pre_autograd_graph(model_to_quantize, example_inputs)
+
     # or capture with dynamic dimensions
+    # for pytorch 2.5+
+    dynamic_shapes = tuple(
+      {0: torch.export.Dim("dim")} if i == 0 else None
+      for i in range(len(example_inputs))
+    )
+    exported_model = torch.export.export_for_training(model_to_quantize, example_inputs, dynamic_shapes=dynamic_shapes).module()
+    
+    # for pytorch 2.4 and before
+    # dynamic_shape API may vary as well
     # from torch._export import dynamic_dim
     # exported_model = capture_pre_autograd_graph(model_to_quantize, example_inputs, constraints=[dynamic_dim(example_inputs[0], 0)])
 
 
-``capture_pre_autograd_graph`` is a short term API, it will be updated to use the offical ``torch.export`` API when that is ready.
-
-
 Import the Backend Specific Quantizer and Configure how to Quantize the Model
 -----------------------------------------------------------------------------
 
@@ -454,7 +460,7 @@ we offer in the long term might change based on feedback from PyTorch users.
        out_fp32, out_scale, out_zero_point, out_quant_min, out_quant_max, torch.int8)
        return out_i8
      
-* Reference Quantized Model Representation (available in the nightly build)
+* Reference Quantized Model Representation
 
   We will have a special representation for selected ops, for example, quantized linear. Other ops are represented as ``dq -> float32_op -> q`` and ``q/dq`` are decomposed into more primitive operators.
   You can get this representation by using ``convert_pt2e(..., use_reference_representation=True)``.
@@ -485,8 +491,6 @@ Now we can compare the size and model accuracy with baseline model.
 .. code-block:: python
 
     # Baseline model size and accuracy
-    scripted_float_model_file = "resnet18_scripted.pth"
-
     print("Size of baseline model")
     print_size_of_model(float_model)
 
@@ -495,6 +499,8 @@ Now we can compare the size and model accuracy with baseline model.
 
     # Quantized model size and accuracy
     print("Size of model after quantization")
+    # export again to remove unused weights
+    quantized_model = torch.export.export_for_training(quantized_model, example_inputs).module()
     print_size_of_model(quantized_model)
 
     top1, top5 = evaluate(quantized_model, criterion, data_loader_test)
diff --git a/prototype_source/pt2e_quant_ptq_x86_inductor.rst b/prototype_source/pt2e_quant_ptq_x86_inductor.rst
new file mode 100644
index 0000000000..39214a5174
--- /dev/null
+++ b/prototype_source/pt2e_quant_ptq_x86_inductor.rst
@@ -0,0 +1,10 @@
+Quantization in PyTorch 2.0 Export Tutorial
+===========================================
+
+This tutorial has been moved.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/prototype/pt2e_quant_x86_inductor.html'" />
diff --git a/prototype_source/pt2e_quant_qat.rst b/prototype_source/pt2e_quant_qat.rst
index d716af5fec..8f11b0730c 100644
--- a/prototype_source/pt2e_quant_qat.rst
+++ b/prototype_source/pt2e_quant_qat.rst
@@ -18,7 +18,7 @@ to the post training quantization (PTQ) flow for the most part:
     prepare_qat_pt2e,
     convert_pt2e,
   )
-  from torch.ao.quantization.quantizer import (
+  from torch.ao.quantization.quantizer.xnnpack_quantizer import (
     XNNPACKQuantizer,
     get_symmetric_quantization_config,
   )
@@ -36,9 +36,9 @@ to the post training quantization (PTQ) flow for the most part:
   m = M()
 
   # Step 1. program capture
-  # NOTE: this API will be updated to torch.export API in the future, but the captured
-  # result shoud mostly stay the same
-  m = capture_pre_autograd_graph(m, *example_inputs)
+  # This is available for pytorch 2.5+, for more details on lower pytorch versions
+  # please check `Export the model with torch.export` section
+  m = torch.export.export_for_training(m, example_inputs).module()
   # we get a model with aten ops
 
   # Step 2. quantization-aware training
@@ -272,24 +272,35 @@ Here is how you can use ``torch.export`` to export the model:
     from torch._export import capture_pre_autograd_graph
 
     example_inputs = (torch.rand(2, 3, 224, 224),)
-    exported_model = capture_pre_autograd_graph(float_model, example_inputs)
+    # for pytorch 2.5+
+    exported_model = torch.export.export_for_training(float_model, example_inputs).module()
+    # for pytorch 2.4 and before
+    # from torch._export import capture_pre_autograd_graph
+    # exported_model = capture_pre_autograd_graph(model_to_quantize, example_inputs)
 
 
 .. code:: python
 
     # or, to capture with dynamic dimensions:
-    from torch._export import dynamic_dim
 
-    example_inputs = (torch.rand(2, 3, 224, 224),)
-    exported_model = capture_pre_autograd_graph(
-        float_model,
-        example_inputs,
-        constraints=[dynamic_dim(example_inputs[0], 0)],
+    # for pytorch 2.5+
+    dynamic_shapes = tuple(
+      {0: torch.export.Dim("dim")} if i == 0 else None
+      for i in range(len(example_inputs))
     )
-.. note::
-
-   ``capture_pre_autograd_graph`` is a short term API, it will be updated to use the offical ``torch.export`` API when that is ready.
-
+    exported_model = torch.export.export_for_training(float_model, example_inputs, dynamic_shapes=dynamic_shapes).module()
+    
+    # for pytorch 2.4 and before
+    # dynamic_shape API may vary as well
+    # from torch._export import dynamic_dim
+
+    # example_inputs = (torch.rand(2, 3, 224, 224),)
+    # exported_model = capture_pre_autograd_graph(
+    #     float_model,
+    #     example_inputs,
+    #     constraints=[dynamic_dim(example_inputs[0], 0)],
+    # )
+    
 
 Import the Backend Specific Quantizer and Configure how to Quantize the Model
 -----------------------------------------------------------------------------
diff --git a/prototype_source/quantization_in_pytorch_2_0_export_tutorial.rst b/prototype_source/quantization_in_pytorch_2_0_export_tutorial.rst
new file mode 100644
index 0000000000..43fd190e99
--- /dev/null
+++ b/prototype_source/quantization_in_pytorch_2_0_export_tutorial.rst
@@ -0,0 +1,10 @@
+Quantization in PyTorch 2.0 Export Tutorial
+===========================================
+
+This tutorial has been moved.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/prototype/pt2e_quant_ptq.html'" />
diff --git a/prototype_source/torchscript_freezing.py b/prototype_source/torchscript_freezing.py
index ca21451d6e..21e49aa50a 100644
--- a/prototype_source/torchscript_freezing.py
+++ b/prototype_source/torchscript_freezing.py
@@ -2,6 +2,8 @@
 Model Freezing in TorchScript
 =============================
 
+.. note:: TorchScript is no longer in active development.
+
 In this tutorial, we introduce the syntax for *model freezing* in TorchScript.
 Freezing is the process of inlining Pytorch module parameters and attributes
 values into the TorchScript internal representation. Parameter and attribute
diff --git a/recipes_source/android_native_app_with_custom_op.rst b/recipes_source/android_native_app_with_custom_op.rst
index c03940b21f..c9dbc093b2 100644
--- a/recipes_source/android_native_app_with_custom_op.rst
+++ b/recipes_source/android_native_app_with_custom_op.rst
@@ -1,735 +1,10 @@
 Making Native Android Application that uses PyTorch prebuilt libraries
 ======================================================================
 
-**Author**: `Ivan Kobzarev <https://github.com/IvanKobzarev>`_
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-In this recipe, you will learn:
+Redirecting in 3 seconds...
 
- - How to make an Android Application that uses LibTorch API from native code (C++).
+.. raw:: html
 
- - How to use within this application TorchScript models with custom operators.
-
-The full setup of this app you can find in `PyTorch Android Demo Application Repository <https://github.com/pytorch/android-demo-app/tree/master/NativeApp>`_.
-
-
-Setup
-~~~~~
-
-You will need a Python 3 environment with the following packages (and their dependencies) installed:
-
-- PyTorch 1.6
-
-For Android development, you will need to install:
-
-- Android NDK
-
-::
-
-  wget https://dl.google.com/android/repository/android-ndk-r19c-linux-x86_64.zip
-  unzip android-ndk-r19c-linux-x86_64.zip
-  export ANDROID_NDK=$(pwd)/android-ndk-r19c
-
-
-- Android SDK
-
-::
-
-  wget https://dl.google.com/android/repository/sdk-tools-linux-3859397.zip
-  unzip sdk-tools-linux-3859397.zip -d android_sdk
-  export ANDROID_HOME=$(pwd)/android_sdk
-
-
-
-- Gradle 4.10.3
-
-Gradle is the most widely used build system for android applications, and we will need it to build our application. Download it and add to the path to use ``gradle`` in the command line.
-
-.. code-block:: shell
-
-  wget https://services.gradle.org/distributions/gradle-4.10.3-bin.zip
-  unzip gradle-4.10.3-bin.zip
-  export GRADLE_HOME=$(pwd)/gradle-4.10.3
-  export PATH="${GRADLE_HOME}/bin/:${PATH}"
-
-- JDK
-
-Gradle requires JDK, you need to install it and set environment variable ``JAVA_HOME`` to point to it.
-For example you can install OpenJDK, following `instructions <https://openjdk.java.net/install/>`_.
-
-- OpenCV SDK for Android
-
-Our custom operator will be implemented using the OpenCV library. To use it for Android, we need to download OpenCV SDK for Android with prebuilt libraries.
-Download from `OpenCV releases page <https://opencv.org/releases/>`_. Unzip it and set the environment variable ``OPENCV_ANDROID_SDK`` to it.
-
-
-Preparing TorchScript Model With Custom C++ Operator
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-TorchScript allows using custom C++ operators, to read about it with details you can read 
-`the dedicated tutorial <https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html>`_.
-
-As a result, you can script the model that uses custom op, that uses OpenCV ``cv::warpPerspective`` function.
-
-.. code-block:: python
-
-  import torch
-  import torch.utils.cpp_extension
-
-  print(torch.version.__version__)
-  op_source = """
-  #include <opencv2/opencv.hpp>
-  #include <torch/script.h>
-
-  torch::Tensor warp_perspective(torch::Tensor image, torch::Tensor warp) {
-    cv::Mat image_mat(/*rows=*/image.size(0),
-                      /*cols=*/image.size(1),
-                      /*type=*/CV_32FC1,
-                      /*data=*/image.data_ptr<float>());
-    cv::Mat warp_mat(/*rows=*/warp.size(0),
-                     /*cols=*/warp.size(1),
-                     /*type=*/CV_32FC1,
-                     /*data=*/warp.data_ptr<float>());
-
-    cv::Mat output_mat;
-    cv::warpPerspective(image_mat, output_mat, warp_mat, /*dsize=*/{64, 64});
-
-    torch::Tensor output =
-      torch::from_blob(output_mat.ptr<float>(), /*sizes=*/{64, 64});
-    return output.clone();
-  }
-
-  static auto registry =
-    torch::RegisterOperators("my_ops::warp_perspective", &warp_perspective);
-  """
-
-  torch.utils.cpp_extension.load_inline(
-      name="warp_perspective",
-      cpp_sources=op_source,
-      extra_ldflags=["-lopencv_core", "-lopencv_imgproc"],
-      is_python_module=False,
-      verbose=True,
-  )
-
-  print(torch.ops.my_ops.warp_perspective)
-
-
-  @torch.jit.script
-  def compute(x, y):
-      if bool(x[0][0] == 42):
-          z = 5
-      else:
-          z = 10
-      x = torch.ops.my_ops.warp_perspective(x, torch.eye(3))
-      return x.matmul(y) + z
-
-
-  compute.save("compute.pt")
-
-
-This snippet generates ``compute.pt`` file which is TorchScript model that uses custom op ``my_ops.warp_perspective``.
-
-You need to have installed OpenCV for development to run it.
-For Linux systems that can be done using the next commands:
-CentOS:
-
-.. code-block:: shell
-
-  yum install opencv-devel
-
-Ubuntu:
-
-.. code-block:: shell
-
-  apt-get install libopencv-dev
-
-Making Android Application
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-After we succeeded in having ``compute.pt``, we want to use this TorchScript model within Android application. Using general TorchScript models (without custom operators) on Android, using Java API, you can find `here <https://pytorch.org/mobile/android/>`_. We can not use this approach for our case, as our model uses a custom operator(``my_ops.warp_perspective``), default TorchScript execution will fail to find it.
-
-Registration of ops is not exposed to PyTorch Java API, thus we need to build Android Application with native part (C++) and using LibTorch C++ API to implement and register the same custom operator for Android. As our operator uses the OpenCV library - we will use prebuilt OpenCV Android libraries and use the same functions from OpenCV.
-
-Let's start creating Android application in ``NativeApp`` folder.
-
-.. code-block:: shell
-  
-  mkdir NativeApp
-  cd NativeApp
-
-Android Application Build Setup
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Android Application build consists of the main gradle part and native build CMake part.
-All the listings here are the full file listing, that if to recreate the whole structure,
-you will be able to build and install the result Android Application without any code additions.
-
-Gradle Build Setup
-------------------
-We will need to add gradle setup files: build.gradle, gradle.properties, settings.gradle.
-More about Android Gradle build configurations you can find `here <https://developer.android.com/studio/build>`_.
-
-``NativeApp/settings.gradle``
-
-.. code-block:: gradle
-
-  include ':app'
-
-
-``NativeApp/gradle.properties``
-
-.. code-block:: gradle
-
-  android.useAndroidX=true
-  android.enableJetifier=true
-
-
-``NativeApp/build.gradle``
-
-.. code-block:: gradle
-
-  buildscript {
-      repositories {
-          google()
-          jcenter()
-      }
-      dependencies {
-          classpath 'com.android.tools.build:gradle:3.5.0'
-      }
-  }
-
-  allprojects {
-      repositories {
-          google()
-          jcenter()
-      }
-  }
-
-
-In ``NativeApp/build.gradle`` we specify Android gradle plugin version `3.5.0`. This version is not recent. Still, we use it as PyTorch android gradle builds use this version.
-
-``NativeApp/settings.gradle`` shows that out project contains only one module - ``app``, which will be our Android Application.
-
-.. code-block:: shell
-
-    mkdir app
-    cd app
-
-
-``NativeApp/app/build.gradle``
-
-.. code-block:: gradle
-  
-  apply plugin: 'com.android.application'
-
-  repositories {
-    jcenter()
-    maven {
-      url "https://oss.sonatype.org/content/repositories/snapshots"
-    }
-  }
-
-  android {
-    configurations {
-      extractForNativeBuild
-    }
-    compileSdkVersion 28
-    buildToolsVersion "29.0.2"
-    defaultConfig {
-      applicationId "org.pytorch.nativeapp"
-      minSdkVersion 21
-      targetSdkVersion 28
-      versionCode 1
-      versionName "1.0"
-      externalNativeBuild {
-        cmake {
-          arguments "-DANDROID_STL=c++_shared"
-        }
-      }
-    }
-    buildTypes {
-      release {
-        minifyEnabled false
-      }
-    }
-    externalNativeBuild {
-      cmake {
-        path "CMakeLists.txt"
-      }
-    }
-    sourceSets {
-      main {
-        jniLibs.srcDirs = ['src/main/jniLibs']
-      }
-    }
-  }
-
-  dependencies {
-    implementation 'com.android.support:appcompat-v7:28.0.0'
-
-    implementation 'org.pytorch:pytorch_android:1.6.0-SNAPSHOT'
-    extractForNativeBuild 'org.pytorch:pytorch_android:1.6.0-SNAPSHOT'
-  }
-
-  task extractAARForNativeBuild {
-    doLast {
-      configurations.extractForNativeBuild.files.each {
-        def file = it.absoluteFile
-        copy {
-          from zipTree(file)
-          into "$buildDir/$file.name"
-          include "headers/**"
-          include "jni/**"
-        }
-      }
-    }
-  }
-
-  tasks.whenTaskAdded { task ->
-    if (task.name.contains('externalNativeBuild')) {
-      task.dependsOn(extractAARForNativeBuild)
-    }
-  }
-
-This gradle build script registers dependencies on pytorch_android snapshots,
-that are published on nightly channels.
-
-As they are published to nexus sonatype repository - we need to register that repository:
-``https://oss.sonatype.org/content/repositories/snapshots``.
-
-In our application we need to use LibTorch C++ API in our application native build part. For this, we need access to prebuilt binaries and headers. They are prepacked in PyTorch Android builds, which is published in Maven repositories.
-
-To use PyTorch Android prebuilt libraries from gradle dependencies (which is aar files) - 
-we should add registration for configuration ``extractForNativeBuild``,
-add this configuration in dependencies and put its definition in the end.
-
-``extractForNativeBuild`` task will call ``extractAARForNativeBuild`` task that unpacks pytorch_android aar
-to gradle build directory.
-
-Pytorch_android aar contains LibTorch headers in ``headers`` folder
-and prebuilt libraries for different Android abis in ``jni`` folder:
-``$ANDROID_ABI/libpytorch_jni.so``, ``$ANDROID_ABI/libfbjni.so``.
-We will use them for our native build.
-
-The native build is registered in this ``build.gradle`` with lines:
-
-.. code-block:: gradle
-
-  android {
-    ...
-    externalNativeBuild {
-      cmake {
-        path "CMakeLists.txt"
-      }
-  }
-  ...
-  defaultConfig {
-    externalNativeBuild {
-      cmake {
-        arguments "-DANDROID_STL=c++_shared"
-      }
-    }
-  }
-
-We will use ``CMake`` configuration for a native build. Here we also specify that we will dynamically link with STL, as we have several libraries. More about this, you can find `here <https://developer.android.com/ndk/guides/cpp-support>`_.
-
-
-Native Build CMake Setup
-------------------------
-
-The native build will be configured in ``NativeApp/app/CMakeLists.txt``:
-
-.. code-block:: cmake
-
-  cmake_minimum_required(VERSION 3.4.1)
-  set(TARGET pytorch_nativeapp)
-  project(${TARGET} CXX)
-  set(CMAKE_CXX_STANDARD 14)
-
-  set(build_DIR ${CMAKE_SOURCE_DIR}/build)
-
-  set(pytorch_testapp_cpp_DIR ${CMAKE_CURRENT_LIST_DIR}/src/main/cpp)
-  file(GLOB pytorch_testapp_SOURCES
-    ${pytorch_testapp_cpp_DIR}/pytorch_nativeapp.cpp
-  )
-
-  add_library(${TARGET} SHARED
-      ${pytorch_testapp_SOURCES}
-  )
-
-  file(GLOB PYTORCH_INCLUDE_DIRS "${build_DIR}/pytorch_android*.aar/headers")
-  file(GLOB PYTORCH_LINK_DIRS "${build_DIR}/pytorch_android*.aar/jni/${ANDROID_ABI}")
-
-  target_compile_options(${TARGET} PRIVATE
-    -fexceptions
-  )
-
-  set(BUILD_SUBDIR ${ANDROID_ABI})
-
-  find_library(PYTORCH_LIBRARY pytorch_jni
-    PATHS ${PYTORCH_LINK_DIRS}
-    NO_CMAKE_FIND_ROOT_PATH)
-  find_library(FBJNI_LIBRARY fbjni
-    PATHS ${PYTORCH_LINK_DIRS}
-    NO_CMAKE_FIND_ROOT_PATH)
-
-  # OpenCV
-  if(NOT DEFINED ENV{OPENCV_ANDROID_SDK})
-    message(FATAL_ERROR "Environment var OPENCV_ANDROID_SDK is not set")
-  endif()
-
-  set(OPENCV_INCLUDE_DIR "$ENV{OPENCV_ANDROID_SDK}/sdk/native/jni/include")
-
-  target_include_directories(${TARGET} PRIVATE
-   "${OPENCV_INCLUDE_DIR}"
-    ${PYTORCH_INCLUDE_DIRS})
-
-  set(OPENCV_LIB_DIR "$ENV{OPENCV_ANDROID_SDK}/sdk/native/libs/${ANDROID_ABI}")
-
-  find_library(OPENCV_LIBRARY opencv_java4
-    PATHS ${OPENCV_LIB_DIR}
-    NO_CMAKE_FIND_ROOT_PATH)
-
-  target_link_libraries(${TARGET}
-    ${PYTORCH_LIBRARY}
-    ${FBJNI_LIBRARY}
-    ${OPENCV_LIBRARY}
-    log)
-
-Here we register only one source file ``pytorch_nativeapp.cpp``.
-
-On the previous step in ``NativeApp/app/build.gradle``, the task ``extractAARForNativeBuild`` extracts headers and native libraries to build directory.  We set ``PYTORCH_INCLUDE_DIRS`` and ``PYTORCH_LINK_DIRS`` to them.
-
-After that, we find libraries ``libpytorch_jni.so`` and ``libfbjni.so`` and add them to the linking of our target.
-
-As we plan to use OpenCV functions to implement our custom operator ``my_ops::warp_perspective`` - we need to link to ``libopencv_java4.so``. It is packaged in OpenCV SDK for Android, that was downloaded on the Setup step.
-In this configuration, we find it by environment variable ``OPENCV_ANDROID_SDK``.
-
-We also link with ``log`` library to be able to log our results to Android LogCat.
-
-As we link to OpenCV Android SDK's ``libopencv_java4.so``, we should copy it to ``NativeApp/app/src/main/jniLibs/${ANDROID_ABI}``
-
-.. code-block:: shell
-
-  cp -R $OPENCV_ANDROID_SDK/sdk/native/libs/* NativeApp/app/src/main/jniLibs/
-
-
-Adding the model file to the application
-----------------------------------------
-
-To package the TorschScript model ``compute.pt`` within our application we should copy it to assets folder:
-
-.. code-block:: shell
-
-  mkdir -p NativeApp/app/src/main/assets
-  cp compute.pt NativeApp/app/src/main/assets
-
-
-Android Application Manifest
-----------------------------
-
-Every Android application has a manifest. 
-Here we specify the application name, package, main activity.
-
-``NativeApp/app/src/main/AndroidManifest.xml``:
-
-.. code-block:: default
-
-  <?xml version="1.0" encoding="utf-8"?>
-  <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-      package="org.pytorch.nativeapp">
-
-      <application
-          android:allowBackup="true"
-          android:label="PyTorchNativeApp"
-          android:supportsRtl="true"
-          android:theme="@style/Theme.AppCompat.Light.DarkActionBar">
-
-          <activity android:name=".MainActivity">
-              <intent-filter>
-                  <action android:name="android.intent.action.MAIN" />
-                  <category android:name="android.intent.category.LAUNCHER" />
-              </intent-filter>
-          </activity>
-      </application>
-  </manifest>
-
-
-Sources
--------
-
-Java Code
----------
-
-Now we are ready to implement our MainActivity in
-
-``NativeApp/app/src/main/java/org/pytorch/nativeapp/MainActivity.java``:
-
-.. code-block:: java
-
-  package org.pytorch.nativeapp;
-
-  import android.content.Context;
-  import android.os.Bundle;
-  import android.util.Log;
-  import androidx.appcompat.app.AppCompatActivity;
-  import java.io.File;
-  import java.io.FileOutputStream;
-  import java.io.IOException;
-  import java.io.InputStream;
-  import java.io.OutputStream;
-
-  public class MainActivity extends AppCompatActivity {
-
-    private static final String TAG = "PyTorchNativeApp";
-
-    public static String assetFilePath(Context context, String assetName) {
-      File file = new File(context.getFilesDir(), assetName);
-      if (file.exists() && file.length() > 0) {
-        return file.getAbsolutePath();
-      }
-
-      try (InputStream is = context.getAssets().open(assetName)) {
-        try (OutputStream os = new FileOutputStream(file)) {
-          byte[] buffer = new byte[4 * 1024];
-          int read;
-          while ((read = is.read(buffer)) != -1) {
-            os.write(buffer, 0, read);
-          }
-          os.flush();
-        }
-        return file.getAbsolutePath();
-      } catch (IOException e) {
-        Log.e(TAG, "Error process asset " + assetName + " to file path");
-      }
-      return null;
-    }
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-      super.onCreate(savedInstanceState);
-      final String modelFileAbsoluteFilePath =
-          new File(assetFilePath(this, "compute.pt")).getAbsolutePath();
-      NativeClient.loadAndForwardModel(modelFileAbsoluteFilePath);
-    }
-  }
-
-
-In the previous step, when we copied our ``compute.pt`` to ``NativeApp/app/src/main/assets`` that file became an Android application asset, which will be packed in application. Android system provides only stream access to it.
-To use this module from LibTorch, we need to materialize it as a file on the disk. ``assetFilePath`` function copies data from the asset input stream, writes it on the disk, and returns absolute file path for it.
-
-``OnCreate`` method of Activity is called just after Activity creation. In this method, we call ``assertFilePath`` and call ``NativeClient`` class that will dispatch it to native code through JNI call.
-
-``NativeClient`` is a helper class with an internal private class ``NativePeer``, which is responsible for working with the native part of our application. It has a static block that will load ``libpytorch_nativeapp.so``, that is build with ``CMakeLists.txt`` that we added on the previous step. The static block will be executed with the first reference of ``NativePeer`` class. It happens in ``NativeClient#loadAndForwardModel``.
-
-``NativeApp/app/src/main/java/org/pytorch/nativeapp/NativeClient.java``:
-
-.. code-block:: java
-
-  package org.pytorch.nativeapp;
-
-  public final class NativeClient {
-
-    public static void loadAndForwardModel(final String modelPath) {
-      NativePeer.loadAndForwardModel(modelPath);
-    }
-
-    private static class NativePeer {
-      static {
-        System.loadLibrary("pytorch_nativeapp");
-      }
-
-      private static native void loadAndForwardModel(final String modelPath);
-    }
-  }
-
-``NativePeer#loadAndForwardModel`` is declared as ``native``, it does not have definition in Java. Call to this method will be re-dispatched through JNI to C++ method in our ``libpytorch_nativeapp.so``, in ``NativeApp/app/src/main/cpp/pytorch_nativeapp.cpp``.
-
-Native code
------------
-
-Now we are ready to write a native part of our application.
-
-``NativeApp/app/src/main/cpp/pytorch_nativeapp.cpp``:
-
-.. code-block:: cpp
-
-  #include <android/log.h>
-  #include <cassert>
-  #include <cmath>
-  #include <pthread.h>
-  #include <unistd.h>
-  #include <vector>
-  #define ALOGI(...)                                                             \
-    __android_log_print(ANDROID_LOG_INFO, "PyTorchNativeApp", __VA_ARGS__)
-  #define ALOGE(...)                                                             \
-    __android_log_print(ANDROID_LOG_ERROR, "PyTorchNativeApp", __VA_ARGS__)
-
-  #include "jni.h"
-
-  #include <opencv2/opencv.hpp>
-  #include <torch/script.h>
-
-  namespace pytorch_nativeapp {
-  namespace {
-  torch::Tensor warp_perspective(torch::Tensor image, torch::Tensor warp) {
-    cv::Mat image_mat(/*rows=*/image.size(0),
-                      /*cols=*/image.size(1),
-                      /*type=*/CV_32FC1,
-                      /*data=*/image.data_ptr<float>());
-    cv::Mat warp_mat(/*rows=*/warp.size(0),
-                     /*cols=*/warp.size(1),
-                     /*type=*/CV_32FC1,
-                     /*data=*/warp.data_ptr<float>());
-
-    cv::Mat output_mat;
-    cv::warpPerspective(image_mat, output_mat, warp_mat, /*dsize=*/{8, 8});
-
-    torch::Tensor output =
-        torch::from_blob(output_mat.ptr<float>(), /*sizes=*/{8, 8});
-    return output.clone();
-  }
-
-  static auto registry =
-      torch::RegisterOperators("my_ops::warp_perspective", &warp_perspective);
-
-  template <typename T> void log(const char *m, T t) {
-    std::ostringstream os;
-    os << t << std::endl;
-    ALOGI("%s %s", m, os.str().c_str());
-  }
-
-  struct JITCallGuard {
-    torch::autograd::AutoGradMode no_autograd_guard{false};
-    torch::AutoNonVariableTypeMode non_var_guard{true};
-    torch::jit::GraphOptimizerEnabledGuard no_optimizer_guard{false};
-  };
-  } // namespace
-
-  static void loadAndForwardModel(JNIEnv *env, jclass, jstring jModelPath) {
-    const char *modelPath = env->GetStringUTFChars(jModelPath, 0);
-    assert(modelPath);
-    JITCallGuard guard;
-    torch::jit::Module module = torch::jit::load(modelPath);
-    module.eval();
-    torch::Tensor x = torch::randn({4, 8});
-    torch::Tensor y = torch::randn({8, 5});
-    log("x:", x);
-    log("y:", y);
-    c10::IValue t_out = module.forward({x, y});
-    log("result:", t_out);
-    env->ReleaseStringUTFChars(jModelPath, modelPath);
-  }
-  } // namespace pytorch_nativeapp
-
-  JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
-    JNIEnv *env;
-    if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
-      return JNI_ERR;
-    }
-
-    jclass c = env->FindClass("org/pytorch/nativeapp/NativeClient$NativePeer");
-    if (c == nullptr) {
-      return JNI_ERR;
-    }
-
-    static const JNINativeMethod methods[] = {
-        {"loadAndForwardModel", "(Ljava/lang/String;)V",
-         (void *)pytorch_nativeapp::loadAndForwardModel},
-    };
-    int rc = env->RegisterNatives(c, methods,
-                                  sizeof(methods) / sizeof(JNINativeMethod));
-
-    if (rc != JNI_OK) {
-      return rc;
-    }
-
-    return JNI_VERSION_1_6;
-  }
-
-
-This listing is quite long, and a few things intermixed here, we will follow control flow to understand how this code works.
-The first place where the control flow arrives is ``JNI_OnLoad``.
-This function is called after loading the library. It is responsible for registering native method, which is called when ``NativePeer#loadAndForwardModel`` called, here it is ``pytorch_nativeapp::loadAndForwardModel`` function.
-
-``pytorch_nativeapp::loadAndForwardModel`` takes as an argument model path.
-First, we extract its ``const char*`` value and loading the module with ``torch::jit::load``.
-
-To load TorchScript model for mobile, we need to set these guards, because mobile build doesn't support 
-features like autograd for smaller build size, placed in ``struct JITCallGuard`` in this example.
-It may change in the future. You can track the latest changes keeping an eye on the 
-`source in PyTorch GitHub <https://github.com/pytorch/pytorch/blob/master/android/pytorch_android/src/main/cpp/pytorch_jni_jit.cpp>`_.
-
-Implementation of method ``warp_perspective`` and registration of it is entirely the same as
-in `tutorial for desktop build <https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html>`_.
-
-Building the app
-----------------
-
-To specify to gradle where is Android SDK and Android NDK, we need to fill ``NativeApp/local.properties``.
-
-.. code-block:: shell
-
-  cd NativeApp
-  echo "sdk.dir=$ANDROID_HOME" >> NativeApp/local.properties
-  echo "ndk.dir=$ANDROID_NDK" >> NativeApp/local.properties
-
-
-To build the result ``apk`` file we run:
-
-.. code-block:: shell
-
-  cd NativeApp
-  gradle app:assembleDebug
-
-To install the app on the connected device:
-
-.. code-block:: shell
-
-  cd NativeApp
-  gradle app::installDebug
-
-After that, you can run the app on the device by clicking on PyTorchNativeApp icon.
-Or you can do it from the command line:
-
-.. code-block:: shell
-
-  adb shell am start -n org.pytorch.nativeapp/.MainActivity
-
-If you check the android logcat:
-
-.. code-block:: shell
-
-  adb logcat -v brief | grep PyTorchNativeApp
-
-
-You should see logs with tag 'PyTorchNativeApp' that prints x, y, and the result of the model forward, which we print with ``log`` function in ``NativeApp/app/src/main/cpp/pytorch_nativeapp.cpp``.
-
-::
-
-  I/PyTorchNativeApp(26968): x: -0.9484 -1.1757 -0.5832  0.9144  0.8867  1.0933 -0.4004 -0.3389
-  I/PyTorchNativeApp(26968): -1.0343  1.5200 -0.7625 -1.5724 -1.2073  0.4613  0.2730 -0.6789
-  I/PyTorchNativeApp(26968): -0.2247 -1.2790  1.0067 -0.9266  0.6034 -0.1941  0.7021 -1.5368
-  I/PyTorchNativeApp(26968): -0.3803 -0.0188  0.2021 -0.7412 -0.2257  0.5044  0.6592  0.0826
-  I/PyTorchNativeApp(26968): [ CPUFloatType{4,8} ]
-  I/PyTorchNativeApp(26968): y: -1.0084  1.8733  0.5435  0.1087 -1.1066
-  I/PyTorchNativeApp(26968): -1.9926  1.1047  0.5311 -0.4944  1.9178
-  I/PyTorchNativeApp(26968): -1.5451  0.8867  1.0473 -1.7571  0.3909
-  I/PyTorchNativeApp(26968):  0.4039  0.5085 -0.2776  0.4080  0.9203
-  I/PyTorchNativeApp(26968):  0.3655  1.4395 -1.4467 -0.9837  0.3335
-  I/PyTorchNativeApp(26968): -0.0445  0.8039 -0.2512 -1.3122  0.6543
-  I/PyTorchNativeApp(26968): -1.5819  0.0525  1.5680 -0.6442 -1.3090
-  I/PyTorchNativeApp(26968): -1.6197 -0.0773 -0.5967 -0.1105 -0.3122
-  I/PyTorchNativeApp(26968): [ CPUFloatType{8,5} ]
-  I/PyTorchNativeApp(26968): result:  16.0274   9.0330   6.0124   9.8644  11.0493
-  I/PyTorchNativeApp(26968):   8.7633   6.9657  12.3469  10.3159  12.0683
-  I/PyTorchNativeApp(26968):  12.4529   9.4559  11.7038   7.8396   6.9716
-  I/PyTorchNativeApp(26968):   8.5279   9.1780  11.3849   8.4368   9.1480
-  I/PyTorchNativeApp(26968):  10.0000  10.0000  10.0000  10.0000  10.0000
-  I/PyTorchNativeApp(26968):  10.0000  10.0000  10.0000  10.0000  10.0000
-  I/PyTorchNativeApp(26968):  10.0000  10.0000  10.0000  10.0000  10.0000
-  I/PyTorchNativeApp(26968):  10.0000  10.0000  10.0000  10.0000  10.0000
-  I/PyTorchNativeApp(26968): [ CPUFloatType{8,5} ]
-
-
-
-The full setup of this app you can find in `PyTorch Android Demo Application Repository <https://github.com/pytorch/android-demo-app/tree/master/NativeApp>`_.
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/distributed_checkpoint_recipe.rst b/recipes_source/distributed_checkpoint_recipe.rst
index 374b5af2b7..950839966c 100644
--- a/recipes_source/distributed_checkpoint_recipe.rst
+++ b/recipes_source/distributed_checkpoint_recipe.rst
@@ -330,9 +330,9 @@ A command line utility is provided for the users convenience, which follows the
 
 .. code-block:: bash
 
-    python -m torch.distributed.checkpoint.format_utils -m <checkpoint location> <location to write formats to> <mode>
+    python -m torch.distributed.checkpoint.format_utils <mode> <checkpoint location> <location to write formats to>
 
-In the command above, ``mode`` is one of ``torch_to_dcp``` or ``dcp_to_torch``.
+In the command above, ``mode`` is one of ``torch_to_dcp`` or ``dcp_to_torch``.
 
 
 Alternatively, methods are also provided for users who may wish to convert checkpoints directly.
diff --git a/recipes_source/distributed_optim_torchscript.rst b/recipes_source/distributed_optim_torchscript.rst
index c5bac179f6..2636738529 100644
--- a/recipes_source/distributed_optim_torchscript.rst
+++ b/recipes_source/distributed_optim_torchscript.rst
@@ -1,8 +1,7 @@
 Distributed Optimizer with TorchScript support
 ==============================================================
 
-.. note:: Distributed Optimizer with TorchScript support is introduced in PyTorch 1.8
-    as a beta feature. This API is subject to change.
+.. note:: TorchScript is no longer in active development.
 
 In this recipe, you will learn:
 
diff --git a/recipes_source/mobile_interpreter.rst b/recipes_source/mobile_interpreter.rst
index 44036e74ff..e6d2056e1a 100644
--- a/recipes_source/mobile_interpreter.rst
+++ b/recipes_source/mobile_interpreter.rst
@@ -1,201 +1,10 @@
 (beta) Efficient mobile interpreter in Android and iOS
 ==================================================================
 
-**Author**: `Chen Lai <https://github.com/cccclai>`_, `Martin Yuan <https://github.com/iseeyuan>`_
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-.. warning::
-    PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://pytorch.org/executorch-overview>`_, PyTorch’s all-new on-device inference library. You can also review our new documentation to learn more about how to build `iOS <https://pytorch.org/executorch/stable/demo-apps-ios.html>`_ and `Android <https://pytorch.org/executorch/stable/demo-apps-android.html>`_ apps with ExecuTorch.
+Redirecting in 3 seconds...
 
-Introduction
-------------
+.. raw:: html
 
-This tutorial introduces the steps to use PyTorch's efficient interpreter on iOS and Android. We will be using an  Image Segmentation demo application as an example.
-
-This application will take advantage of the pre-built interpreter libraries available for Android and iOS, which can be used directly with Maven (Android) and CocoaPods (iOS). It is important to note that the pre-built libraries are the available for simplicity, but further size optimization can be achieved with by utilizing PyTorch's custom build capabilities.
-
-.. note:: If you see the error message: `PytorchStreamReader failed locating file bytecode.pkl: file not found ()`, likely you are using a torch script model that requires the use of the PyTorch JIT interpreter (a version of our PyTorch interpreter that is not as size-efficient). In order to leverage our efficient interpreter, please regenerate the model by running: `module._save_for_lite_interpreter(${model_path})`.
-
-   - If `bytecode.pkl` is missing, likely the model is generated with the api: `module.save(${model_psth})`.
-   - The api `_load_for_lite_interpreter(${model_psth})` can be helpful to validate model with the efficient mobile interpreter.
-
-Android
--------------------
-Get the Image Segmentation demo app in Android: https://github.com/pytorch/android-demo-app/tree/master/ImageSegmentation
-
-1. **Prepare model**: Prepare the mobile interpreter version of model by run the script below to generate the scripted model `deeplabv3_scripted.pt` and `deeplabv3_scripted.ptl`
-
-.. code:: python
-
-    import torch
-    from torch.utils.mobile_optimizer import optimize_for_mobile
-    model = torch.hub.load('pytorch/vision:v0.7.0', 'deeplabv3_resnet50', pretrained=True)
-    model.eval()
-
-    scripted_module = torch.jit.script(model)
-    # Export full jit version model (not compatible mobile interpreter), leave it here for comparison
-    scripted_module.save("deeplabv3_scripted.pt")
-    # Export mobile interpreter version model (compatible with mobile interpreter)
-    optimized_scripted_module = optimize_for_mobile(scripted_module)
-    optimized_scripted_module._save_for_lite_interpreter("deeplabv3_scripted.ptl")
-
-2. **Use the PyTorch Android library in the ImageSegmentation app**: Update the `dependencies` part of ``ImageSegmentation/app/build.gradle`` to
-
-.. code:: gradle
-
-    repositories {
-        maven {
-            url "https://oss.sonatype.org/content/repositories/snapshots"
-        }
-    }
-
-    dependencies {
-        implementation 'androidx.appcompat:appcompat:1.2.0'
-        implementation 'androidx.constraintlayout:constraintlayout:2.0.2'
-        testImplementation 'junit:junit:4.12'
-        androidTestImplementation 'androidx.test.ext:junit:1.1.2'
-        androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
-        implementation 'org.pytorch:pytorch_android_lite:1.9.0'
-        implementation 'org.pytorch:pytorch_android_torchvision:1.9.0'
-
-        implementation 'com.facebook.fbjni:fbjni-java-only:0.0.3'
-    }
-
-
-
-3. **Update model loader api**: Update ``ImageSegmentation/app/src/main/java/org/pytorch/imagesegmentation/MainActivity.java`` by
-
-  4.1 Add new import: `import org.pytorch.LiteModuleLoader`
-
-  4.2 Replace the way to load pytorch lite model
-
-.. code:: java
-
-    // mModule = Module.load(MainActivity.assetFilePath(getApplicationContext(), "deeplabv3_scripted.pt"));
-    mModule = LiteModuleLoader.load(MainActivity.assetFilePath(getApplicationContext(), "deeplabv3_scripted.ptl"));
-
-4. **Test app**: Build and run the `ImageSegmentation` app in Android Studio
-
-iOS
--------------------
-Get ImageSegmentation demo app in iOS: https://github.com/pytorch/ios-demo-app/tree/master/ImageSegmentation
-
-1. **Prepare model**: Same as Android.
-
-2. **Build the project with Cocoapods and prebuilt interpreter** Update the `PodFile` and run `pod install`:
-
-.. code-block:: podfile
-
-    target 'ImageSegmentation' do
-    # Comment the next line if you don't want to use dynamic frameworks
-    use_frameworks!
-
-    # Pods for ImageSegmentation
-    pod 'LibTorch_Lite', '~>1.9.0'
-    end
-
-3. **Update library and API**
-
-  3.1 Update ``TorchModule.mm``: To use the custom built libraries project, use `<Libtorch-Lite.h>` (in ``TorchModule.mm``):
-
-.. code-block:: swift
-
-    #import <Libtorch-Lite.h>
-    // If it's built from source with xcode, comment out the line above
-    // and use following headers
-    // #include <torch/csrc/jit/mobile/import.h>
-    // #include <torch/csrc/jit/mobile/module.h>
-    // #include <torch/script.h>
-
-.. code-block:: swift
-
-    @implementation TorchModule {
-    @protected
-    // torch::jit::script::Module _impl;
-     torch::jit::mobile::Module _impl;
-    }
-
-    - (nullable instancetype)initWithFileAtPath:(NSString*)filePath {
-      self = [super init];
-      if (self) {
-          try {
-              _impl = torch::jit::_load_for_mobile(filePath.UTF8String);
-             //  _impl = torch::jit::load(filePath.UTF8String);
-             //  _impl.eval();
-            } catch (const std::exception& exception) {
-                NSLog(@"%s", exception.what());
-                return nil;
-            }
-        }
-        return self;
-    }
-
-3.2 Update ``ViewController.swift``
-
-.. code-block:: swift
-
-    //  if let filePath = Bundle.main.path(forResource:
-    //      "deeplabv3_scripted", ofType: "pt"),
-    //      let module = TorchModule(fileAtPath: filePath) {
-    //      return module
-    //  } else {
-    //      fatalError("Can't find the model file!")
-    //  }
-    if let filePath = Bundle.main.path(forResource:
-        "deeplabv3_scripted", ofType: "ptl"),
-        let module = TorchModule(fileAtPath: filePath) {
-        return module
-    } else {
-        fatalError("Can't find the model file!")
-    }
-
-4. Build and test the app in Xcode.
-
-How to use mobile interpreter + custom build
----------------------------------------------
-A custom PyTorch interpreter library can be created to reduce binary size, by only containing the operators needed by the model. In order to do that follow these steps:
-
-1. To dump the operators in your model, say `deeplabv3_scripted`, run the following lines of Python code:
-
-.. code-block:: python
-
-    # Dump list of operators used by deeplabv3_scripted:
-    import torch, yaml
-    model = torch.jit.load('deeplabv3_scripted.ptl')
-    ops = torch.jit.export_opnames(model)
-    with open('deeplabv3_scripted.yaml', 'w') as output:
-        yaml.dump(ops, output)
-
-In the snippet above, you first need to load the ScriptModule. Then, use export_opnames to return a list of operator names of the ScriptModule and its submodules. Lastly, save the result in a yaml file. The yaml file can be generated for any PyTorch 1.4.0 or above version. You can do that by checking the value of `torch.__version__`.
-
-2. To run the build script locally with the prepared yaml list of operators, pass in the yaml file generate from the last step into the environment variable SELECTED_OP_LIST. Also in the arguments, specify BUILD_PYTORCH_MOBILE=1 as well as the platform/architechture type.
-
-**iOS**: Take the simulator build for example, the command should be:
-
-.. code-block:: bash
-
-   SELECTED_OP_LIST=deeplabv3_scripted.yaml BUILD_PYTORCH_MOBILE=1 IOS_PLATFORM=SIMULATOR ./scripts/build_ios.sh
-
-**Android**: Take the x86 build for example, the command should be:
-
-.. code-block:: bash
-
-   SELECTED_OP_LIST=deeplabv3_scripted.yaml ./scripts/build_pytorch_android.sh x86
-
-
-
-Conclusion
-----------
-
-In this tutorial, we demonstrated how to use PyTorch's efficient mobile interpreter, in an Android and iOS app.
-
-We walked through an Image Segmentation example to show how to dump the model, build a custom torch library from source and use the new api to run model.
-
-Our efficient mobile interpreter is still under development, and we will continue improving its size in the future. Note, however, that the APIs are subject to change in future versions.
-
-Thanks for reading! As always, we welcome any feedback, so please create an issue `here <https://github.com/pytorch/pytorch/issues>` - if you have any.
-
-Learn More
-----------
-
-- To learn more about PyTorch Mobile, please refer to `PyTorch Mobile Home Page <https://pytorch.org/mobile/home/>`_
-- To learn more about Image Segmentation, please refer to the `Image Segmentation DeepLabV3 on Android Recipe <https://pytorch.org/tutorials/beginner/deeplabv3_on_android.html>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/mobile_perf.rst b/recipes_source/mobile_perf.rst
index 14f183ab69..8835ddecc6 100644
--- a/recipes_source/mobile_perf.rst
+++ b/recipes_source/mobile_perf.rst
@@ -1,359 +1,10 @@
 Pytorch Mobile Performance Recipes
 ==================================
 
-.. warning::
-    PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://pytorch.org/executorch-overview>`_, PyTorch’s all-new on-device inference library. You can also learn more about `quantization <https://pytorch.org/executorch/stable/quantization-overview.html>`_, `Hardware acceleration (op fusion using hw) <https://pytorch.org/executorch/stable/examples-end-to-end-to-lower-model-to-delegate.html>`_, and `benchmarking <https://pytorch.org/executorch/stable/sdk-profiling.html>`_ on ExecuTorch’s documentation pages.
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-Introduction
-----------------
-Performance (aka latency) is crucial to most, if not all,
-applications and use-cases of ML model inference on mobile devices.
+Redirecting in 3 seconds...
 
-Today, PyTorch executes the models on the CPU backend pending availability
-of other hardware backends such as GPU, DSP, and NPU.
+.. raw:: html
 
-In this recipe, you will learn:
-
-- How to optimize your model to help decrease execution time (higher performance, lower latency) on the mobile device.
-- How to benchmark (to check if optimizations helped your use case).
-
-
-Model preparation
------------------
-
-We will start with preparing to optimize your model to help decrease execution time
-(higher performance, lower latency) on the mobile device.
-
-
-Setup
-^^^^^^^
-
-First we need to installed pytorch using conda or pip with version at least 1.5.0.
-
-::
-
-   conda install pytorch torchvision -c pytorch
-
-or
-
-::
-
-   pip install torch torchvision
-
-Code your model:
-
-::
-
-  import torch
-  from torch.utils.mobile_optimizer import optimize_for_mobile
-
-  class AnnotatedConvBnReLUModel(torch.nn.Module):
-      def __init__(self):
-          super(AnnotatedConvBnReLUModel, self).__init__()
-          self.conv = torch.nn.Conv2d(3, 5, 3, bias=False).to(dtype=torch.float)
-          self.bn = torch.nn.BatchNorm2d(5).to(dtype=torch.float)
-          self.relu = torch.nn.ReLU(inplace=True)
-          self.quant = torch.quantization.QuantStub()
-          self.dequant = torch.quantization.DeQuantStub()
-
-      def forward(self, x):
-          x = x.contiguous(memory_format=torch.channels_last)
-          x = self.quant(x)
-          x = self.conv(x)
-          x = self.bn(x)
-          x = self.relu(x)
-          x = self.dequant(x)
-          return x
-
-  model = AnnotatedConvBnReLUModel()
-
-
-``torch.quantization.QuantStub`` and ``torch.quantization.DeQuantStub()`` are no-op stubs, which will be used for quantization step.
-
-
-1. Fuse operators using ``torch.quantization.fuse_modules``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Do not be confused that fuse_modules is in the quantization package.
-It works for all ``torch.nn.Module``.
-
-``torch.quantization.fuse_modules`` fuses a list of modules into a single module.
-It fuses only the following sequence of modules:
-
-- Convolution, Batch normalization
-- Convolution, Batch normalization, Relu
-- Convolution, Relu
-- Linear, Relu
-
-This script will fuse Convolution, Batch Normalization and Relu in previously declared model.
-
-::
-
-  torch.quantization.fuse_modules(model, [['conv', 'bn', 'relu']], inplace=True)
-
-
-2. Quantize your model
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-You can find more about PyTorch quantization in
-`the dedicated tutorial <https://pytorch.org/blog/introduction-to-quantization-on-pytorch/>`_.
-
-Quantization of the model not only moves computation to int8,
-but also reduces the size of your model on a disk.
-That size reduction helps to reduce disk read operations during the first load of the model and decreases the amount of RAM.
-Both of those resources can be crucial for the performance of mobile applications.
-This code does quantization, using stub for model calibration function, you can find more about it `here <https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html#post-training-static-quantization>`__.
-
-::
-
-  model.qconfig = torch.quantization.get_default_qconfig('qnnpack')
-  torch.quantization.prepare(model, inplace=True)
-  # Calibrate your model
-  def calibrate(model, calibration_data):
-      # Your calibration code here
-      return
-  calibrate(model, [])
-  torch.quantization.convert(model, inplace=True)
-
-
-
-3. Use torch.utils.mobile_optimizer
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Torch mobile_optimizer package does several optimizations with the scripted model,
-which will help to conv2d and linear operations.
-It pre-packs model weights in an optimized format and fuses ops above with relu
-if it is the next operation.
-
-First we script the result model from previous step:
-
-::
-
-  torchscript_model = torch.jit.script(model)
-
-Next we call ``optimize_for_mobile`` and save model on the disk.
-
-::
-
-  torchscript_model_optimized = optimize_for_mobile(torchscript_model)
-  torch.jit.save(torchscript_model_optimized, "model.pt")
-
-4. Prefer Using Channels Last Tensor memory format
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Channels Last(NHWC) memory format was introduced in PyTorch 1.4.0. It is supported only for four-dimensional tensors. This memory format gives a better memory locality for most operators, especially convolution. Our measurements showed a 3x speedup of MobileNetV2 model compared with the default Channels First(NCHW) format.
-
-At the moment of writing this recipe, PyTorch Android java API does not support using inputs in Channels Last memory format. But it can be used on the TorchScript model level, by adding the conversion to it for model inputs.
-
-.. code-block:: python
-
-  def forward(self, x):
-      x = x.contiguous(memory_format=torch.channels_last)
-      ...
-
-
-This conversion is zero cost if your input is already in Channels Last memory format. After it, all operators will work preserving ChannelsLast memory format.
-
-5. Android - Reusing tensors for forward
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-This part of the recipe is Android only.
-
-Memory is a critical resource for android performance, especially on old devices.
-Tensors can need a significant amount of memory.
-For example, standard computer vision tensor contains 1*3*224*224 elements,
-assuming that data type is float and will need 588Kb of memory.
-
-::
-
-  FloatBuffer buffer = Tensor.allocateFloatBuffer(1*3*224*224);
-  Tensor tensor = Tensor.fromBlob(buffer, new long[]{1, 3, 224, 224});
-
-
-Here we allocate native memory as ``java.nio.FloatBuffer`` and creating ``org.pytorch.Tensor`` which storage will be pointing to the memory of the allocated buffer.
-
-For most of the use cases, we do not do model forward only once, repeating it with some frequency or as fast as possible.
-
-If we are doing new memory allocation for every module forward - that will be suboptimal.
-Instead of this, we can reuse the same memory that we allocated on the previous step, fill it with new data, and run module forward again on the same tensor object.
-
-You can check how it looks in code in `pytorch android application example <https://github.com/pytorch/android-demo-app/blob/master/PyTorchDemoApp/app/src/main/java/org/pytorch/demo/vision/ImageClassificationActivity.java#L174>`_.
-
-::
-
-  protected AnalysisResult analyzeImage(ImageProxy image, int rotationDegrees) {
-    if (mModule == null) {
-      mModule = Module.load(moduleFileAbsoluteFilePath);
-      mInputTensorBuffer =
-      Tensor.allocateFloatBuffer(3 * 224 * 224);
-      mInputTensor = Tensor.fromBlob(mInputTensorBuffer, new long[]{1, 3, 224, 224});
-    }
-
-    TensorImageUtils.imageYUV420CenterCropToFloatBuffer(
-        image.getImage(), rotationDegrees,
-        224, 224,
-        TensorImageUtils.TORCHVISION_NORM_MEAN_RGB,
-        TensorImageUtils.TORCHVISION_NORM_STD_RGB,
-        mInputTensorBuffer, 0);
-
-    Tensor outputTensor = mModule.forward(IValue.from(mInputTensor)).toTensor();
-  }
-
-Member fields ``mModule``, ``mInputTensorBuffer`` and ``mInputTensor`` are initialized only once
-and buffer is refilled using ``org.pytorch.torchvision.TensorImageUtils.imageYUV420CenterCropToFloatBuffer``.
-
-6. Load time optimization
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-**Available since Pytorch 1.13**
-
-PyTorch Mobile also supports a FlatBuffer-based file format that is faster
-to load. Both flatbuffer and pickle-based model file can be load with the
-same ``_load_for_lite_interpreter`` (Python) or ``_load_for_mobile``(C++) API.
-
-To use the FlatBuffer format, instead of creating the model file with
-``model._save_for_lite_interpreter('path/to/file.ptl')``, you can run the following command:
-
-
-One can save using
-
-::
-
-  model._save_for_lite_interpreter('path/to/file.ptl', _use_flatbuffer=True)
-
-
-The extra argument ``_use_flatbuffer`` makes a FlatBuffer file instead of a
-zip file. The created file will be faster to load.
-
-For example, using ResNet-50 and running the following script:
-
-::
-
-  import torch
-  from torch.jit import mobile
-  import time
-  model = torch.hub.load('pytorch/vision:v0.10.0', 'deeplabv3_resnet50', pretrained=True)
-  model.eval()
-  jit_model = torch.jit.script(model)
-
-  jit_model._save_for_lite_interpreter('/tmp/jit_model.ptl')
-  jit_model._save_for_lite_interpreter('/tmp/jit_model.ff', _use_flatbuffer=True)
-
-  import timeit
-  print('Load ptl file:')
-  print(timeit.timeit('from torch.jit import mobile; mobile._load_for_lite_interpreter("/tmp/jit_model.ptl")',
-                         number=20))
-  print('Load flatbuffer file:')
-  print(timeit.timeit('from torch.jit import mobile; mobile._load_for_lite_interpreter("/tmp/jit_model.ff")',
-                         number=20))
-
-
-
-you would get the following result:
-
-::
-
-  Load ptl file:
-  0.5387594579999999
-  Load flatbuffer file:
-  0.038842832999999466
-
-While speed ups on actual mobile devices will be smaller, you can still expect
-3x - 6x load time reductions.
-
-### Reasons to avoid using a FlatBuffer-based mobile model
-
-However, FlatBuffer format also has some limitations that you might want to consider:
-
-* It is only available in PyTorch 1.13 or later. Therefore, client devices compiled
-  with earlier PyTorch versions might not be able to load it.
-* The Flatbuffer library imposes a 4GB limit for file sizes. So it is not suitable
-  for large models.
-
-Benchmarking
-------------
-
-The best way to benchmark (to check if optimizations helped your use case) - is to measure your particular use case that you want to optimize, as performance behavior can vary in different environments.
-
-PyTorch distribution provides a way to benchmark naked binary that runs the model forward,
-this approach can give more stable measurements rather than testing inside the application.
-
-
-Android - Benchmarking Setup
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-This part of the recipe is Android only.
-
-For this you first need to build benchmark binary:
-
-::
-
-    <from-your-root-pytorch-dir>
-    rm -rf build_android
-    BUILD_PYTORCH_MOBILE=1 ANDROID_ABI=arm64-v8a ./scripts/build_android.sh -DBUILD_BINARY=ON
-
-You should have arm64 binary at: ``build_android/bin/speed_benchmark_torch``.
-This binary takes ``--model=<path-to-model>``, ``--input_dim="1,3,224,224"`` as dimension information for the input and ``--input_type="float"`` as the type of the input as arguments.
-
-Once you have your android device connected,
-push speedbenchark_torch binary and your model to the phone:
-
-::
-
-  adb push <speedbenchmark-torch> /data/local/tmp
-  adb push <path-to-scripted-model> /data/local/tmp
-
-
-Now we are ready to benchmark your model:
-
-::
-
-  adb shell "/data/local/tmp/speed_benchmark_torch --model=/data/local/tmp/model.pt" --input_dims="1,3,224,224" --input_type="float"
-  ----- output -----
-  Starting benchmark.
-  Running warmup runs.
-  Main runs.
-  Main run finished. Microseconds per iter: 121318. Iters per second: 8.24281
-
-
-iOS - Benchmarking Setup
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-For iOS, we'll be using our `TestApp <https://github.com/pytorch/pytorch/tree/master/ios/TestApp>`_ as the benchmarking tool.
-
-To begin with, let's apply the ``optimize_for_mobile`` method to our python script located at `TestApp/benchmark/trace_model.py <https://github.com/pytorch/pytorch/blob/master/ios/TestApp/benchmark/trace_model.py>`_. Simply modify the code as below.
-
-::
-
-  import torch
-  import torchvision
-  from torch.utils.mobile_optimizer import optimize_for_mobile
-
-  model = torchvision.models.mobilenet_v2(pretrained=True)
-  model.eval()
-  example = torch.rand(1, 3, 224, 224)
-  traced_script_module = torch.jit.trace(model, example)
-  torchscript_model_optimized = optimize_for_mobile(traced_script_module)
-  torch.jit.save(torchscript_model_optimized, "model.pt")
-
-Now let's run ``python trace_model.py``. If everything works well, we should be able to generate our optimized model in the benchmark directory.
-
-Next, we're going to build the PyTorch libraries from source.
-
-::
-
-  BUILD_PYTORCH_MOBILE=1 IOS_ARCH=arm64 ./scripts/build_ios.sh
-
-Now that we have the optimized model and PyTorch ready, it's time to generate our XCode project and do benchmarking. To do that, we'll be using a ruby script - `setup.rb` which does the heavy lifting jobs of setting up the XCode project.
-
-::
-
-  ruby setup.rb
-
-Now open the `TestApp.xcodeproj` and plug in your iPhone, you're ready to go. Below is an example result from iPhoneX
-
-::
-
-  TestApp[2121:722447] Main runs
-  TestApp[2121:722447] Main run finished. Milliseconds per iter: 28.767
-  TestApp[2121:722447] Iters per second: : 34.762
-  TestApp[2121:722447] Done.
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/model_preparation_android.rst b/recipes_source/model_preparation_android.rst
index 55ef7d9735..22c0e17df3 100644
--- a/recipes_source/model_preparation_android.rst
+++ b/recipes_source/model_preparation_android.rst
@@ -1,85 +1,10 @@
 Model Preparation for Android Recipe
 =====================================
 
-This recipe demonstrates how to prepare a PyTorch MobileNet v2 image classification model for Android apps, and how to set up Android projects to use the mobile-ready model file.
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-Introduction
------------------
+Redirecting in 3 seconds...
 
-After a PyTorch model is trained or a pre-trained model is made available, it is normally not ready to be used in mobile apps yet. It needs to be quantized (see the `Quantization Recipe <quantization.html>`_), converted to TorchScript so Android apps can load it, and optimized for mobile apps. Furthermore, Android apps need to be set up correctly to enable the use of PyTorch Mobile libraries, before they can load and use the model for inference.
+.. raw:: html
 
-Pre-requisites
------------------
-
-PyTorch 1.6.0 or 1.7.0
-
-torchvision 0.6.0 or 0.7.0
-
-Android Studio 3.5.1 or above with NDK installed
-
-Steps
------------------
-
-1. Get Pretrained and Quantized MobileNet v2 Model
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-To get the MobileNet v2 quantized model, simply do:
-
-::
-
-    import torchvision
-
-    model_quantized = torchvision.models.quantization.mobilenet_v2(pretrained=True, quantize=True)
-
-2. Script and Optimize the Model for Mobile Apps
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Use either the `script` or `trace` method to convert the quantized model to the TorchScript format:
-
-::
-
-    import torch
-
-    dummy_input = torch.rand(1, 3, 224, 224)
-    torchscript_model = torch.jit.trace(model_quantized, dummy_input)
-
-or
-
-::
-
-    torchscript_model = torch.jit.script(model_quantized)
-
-
-.. warning::
-    The `trace` method only scripts the code path executed during the trace, so it will not work properly for models that include decision branches. See the `Script and Optimize for Mobile Recipe <script_optimized.html>`_ for more details.
-
-Then optimize the TorchScript formatted model for mobile and save it:
-
-::
-
-    from torch.utils.mobile_optimizer import optimize_for_mobile
-    torchscript_model_optimized = optimize_for_mobile(torchscript_model)
-    torch.jit.save(torchscript_model_optimized, "mobilenetv2_quantized.pt")
-
-With the total 7 or 8 (depending on if the `script` or `trace` method is called to get the TorchScript format of the model) lines of code in the two steps above, we have a model ready to be added to mobile apps.
-
-3. Add the Model and PyTorch Library on Android
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-* In your current or a new Android Studio project, open the build.gradle file, and add the following two lines (the second one is required only if you plan to use a TorchVision model):
-
-::
-
-    implementation 'org.pytorch:pytorch_android:1.6.0'
-    implementation 'org.pytorch:pytorch_android_torchvision:1.6.0'
-
-* Drag and drop the model file `mobilenetv2_quantized.pt` to your project's assets folder.
-
-That's it! Now you can build your Android app with the PyTorch library and the model ready to use. To actually write code to use the model, refer to the PyTorch Mobile `Android Quickstart with a HelloWorld Example <https://pytorch.org/mobile/android/#quickstart-with-a-helloworld-example>`_ and `Android Hackathon Example <https://github.com/pytorch/workshops/tree/master/PTMobileWalkthruAndroid>`_.
-
-Learn More
------------------
-
-1. `PyTorch Mobile site <https://pytorch.org/mobile>`_
-
-2. `Introduction to TorchScript <https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/model_preparation_ios.rst b/recipes_source/model_preparation_ios.rst
index 2fbacd7fa6..cbb4927eae 100644
--- a/recipes_source/model_preparation_ios.rst
+++ b/recipes_source/model_preparation_ios.rst
@@ -1,95 +1,10 @@
 Model Preparation for iOS Recipe
 =====================================
 
-This recipe demonstrates how to prepare a PyTorch MobileNet v2 image classification model for iOS apps, and how to set up an iOS project to use the mobile-ready model file.
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-Introduction
------------------
+Redirecting in 3 seconds...
 
-After a PyTorch model is trained or a pre-trained model is made available, it is normally not ready to be used in mobile apps yet. It needs to be quantized (see `Quantization Recipe <quantization.html>`_ for more details), converted to TorchScript so iOS apps can load it and optimized for mobile apps (see `Script and Optimize for Mobile Recipe <script_optimized.html>`_). Furthermore, iOS apps need to be set up correctly to enable the use of PyTorch Mobile libraries, before they can load and use the model for inference.
+.. raw:: html
 
-Pre-requisites
------------------
-
-PyTorch 1.6.0 or 1.7.0
-
-torchvision 0.6.0 or 0.7.0
-
-Xcode 11 or 12
-
-Steps
------------------
-
-1. Get Pretrained and Quantized MobileNet v2 Model
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-To get the MobileNet v2 quantized model, simply do:
-
-::
-
-    import torchvision
-
-    model_quantized = torchvision.models.quantization.mobilenet_v2(pretrained=True, quantize=True)
-
-2. Script and Optimize the Model for Mobile Apps
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Use either the script or trace method to convert the quantized model to the TorchScript format:
-
-::
-
-    import torch
-
-    dummy_input = torch.rand(1, 3, 224, 224)
-    torchscript_model = torch.jit.trace(model_quantized, dummy_input)
-
-or
-
-::
-
-    torchscript_model = torch.jit.script(model_quantized)
-
-.. warning::
-    The `trace` method only scripts the code path executed during the trace, so it will not work properly for models that include decision branches. See the `Script and Optimize for Mobile Recipe <script_optimized.html>`_ for more details.
-
-
-Then optimize the TorchScript formatted model for mobile and save it:
-
-::
-
-    from torch.utils.mobile_optimizer import optimize_for_mobile
-    torchscript_model_optimized = optimize_for_mobile(torchscript_model)
-    torch.jit.save(torchscript_model_optimized, "mobilenetv2_quantized.pt")
-
-With the total 7 or 8 (depending on if the script or trace method is called to get the TorchScript format of the model) lines of code in the two steps above, we have a model ready to be added to mobile apps.
-
-3. Add the Model and PyTorch Library on iOS
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-To use the mobile-ready model `mobilenetv2_quantized.pt` in an iOS app, either create a new Xcode project or in your existing Xcode project, then follow the steps below:
-
-* Open a Mac Terminal, cd to your iOS app's project folder;
-
-* If your iOS app does not use Cocoapods yet, run `pod init` first to generate the `Podfile` file.
-
-* Edit `Podfile` either from Xcode or any editor, and add the following line under the target:
-
-::
-
-    pod 'LibTorch', '~>1.6.1'
-
-* Run `pod install` from the Terminal and then open your project's xcworkspace file;
-
-* Save the two files `TorchModule.h` and `TorchModule.mm` from `here <https://github.com/pytorch/ios-demo-app/tree/master/HelloWorld/HelloWorld/HelloWorld/TorchBridge>`_ and drag and drop them to your project. If your project is Swift based, a message box with the title "Would you like to configure an Objective-C bridging header?" will show up; click the "Create Bridging Header" button to create a Swift to Objective-c bridging header file, and add `#import "TorchModule.h"` to the header file `<your_project_name>-Bridging-Header.h`;
-
-* Drag and drop the model file `mobilenetv2_quantized.pt` to the project.
-
-After these steps, you can successfully build and run your Xcode project. To actually write code to use the model, refer to the PyTorch Mobile `iOS Code Walkthrough <https://pytorch.org/mobile/ios/#code-walkthrough>`_ and two complete ready-to-run sample iOS apps `HelloWorld <https://github.com/pytorch/ios-demo-app/tree/master/HelloWorld>`_ and `iOS Hackathon Example <https://github.com/pytorch/workshops/tree/master/PTMobileWalkthruIOS>`_.
-
-
-Learn More
------------------
-
-1. `PyTorch Mobile site <https://pytorch.org/mobile>`_
-
-2. `Introduction to TorchScript <https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/profile_with_itt.rst b/recipes_source/profile_with_itt.rst
index 7ddb1ab3fe..566fd614f2 100644
--- a/recipes_source/profile_with_itt.rst
+++ b/recipes_source/profile_with_itt.rst
@@ -58,6 +58,10 @@ Launch Intel® VTune™ Profiler
 
 To verify the functionality, you need to start an Intel® VTune™ Profiler instance. Please check the `Intel® VTune™ Profiler User Guide <https://www.intel.com/content/www/us/en/develop/documentation/vtune-help/top/launch.html>`__ for steps to launch Intel® VTune™ Profiler.
 
+.. note:: 
+        Users can also use web-server-ui by following  `Intel® VTune™ Profiler Web Server UI Guide <https://www.intel.com/content/www/us/en/docs/vtune-profiler/user-guide/2024-1/web-server-ui.html>`__
+        ex :  vtune-backend --web-port=8080  --allow-remote-access --enable-server-profiling
+
 Once you get the Intel® VTune™ Profiler GUI launched, you should see a user interface as below:
 
 .. figure:: /_static/img/itt_tutorial/vtune_start.png
@@ -66,8 +70,8 @@ Once you get the Intel® VTune™ Profiler GUI launched, you should see a user i
 
 Three sample results are available on the left side navigation bar under `sample (matrix)` project. If you do not want profiling results appear in this default sample project, you can create a new project via the button `New Project...` under the blue `Configure Analysis...` button. To start a new profiling, click the blue `Configure Analysis...` button to initiate configuration of the profiling.
 
-Configure Profiling
-~~~~~~~~~~~~~~~~~~~
+Configure Profiling for CPU
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Once you click the `Configure Analysis...` button, you should see the screen below:
 
@@ -77,6 +81,16 @@ Once you click the `Configure Analysis...` button, you should see the screen bel
 
 The right side of the windows is split into 3 parts: `WHERE` (top left), `WHAT` (bottom left), and `HOW` (right). With `WHERE`, you can assign a machine where you want to run the profiling on. With `WHAT`, you can set the path of the application that you want to profile. To profile a PyTorch script, it is recommended to wrap all manual steps, including activating a Python environment and setting required environment variables, into a bash script, then profile this bash script. In the screenshot above, we wrapped all steps into the `launch.sh` bash script and profile `bash` with the parameter to be `<path_of_launch.sh>`. On the right side `HOW`, you can choose whatever type that you would like to profile. Intel® VTune™ Profiler provides a bunch of profiling types that you can choose from. Details can be found at `Intel® VTune™ Profiler User Guide <https://www.intel.com/content/www/us/en/develop/documentation/vtune-help/top/analyze-performance.html>`__.
 
+
+Configure Profiling for XPU
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Pick GPU Offload Profiling Type instead of Hotspots, and follow the same instructions as CPU to Launch the Application. 
+
+.. figure:: /_static/img/itt_tutorial/vtune_xpu_config.png
+   :width: 100%
+   :align: center
+
+
 Read Profiling Result
 ~~~~~~~~~~~~~~~~~~~~~
 
@@ -101,6 +115,18 @@ As illustrated on the right side navigation bar, brown portions in the timeline
 
 Of course there are much more enriched sets of profiling features that Intel® VTune™ Profiler provides to help you understand a performance issue. When you understand the root cause of a performance issue, you can get it fixed. More detailed usage instructions are available at `Intel® VTune™ Profiler User Guide <https://www.intel.com/content/www/us/en/develop/documentation/vtune-help/top/analyze-performance.html>`__.
 
+Read XPU Profiling Result
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+With a successful profiling with ITT, you can open `Platform` tab of the profiling result to see labels in the Intel® VTune™ Profiler timeline.
+
+.. figure:: /_static/img/itt_tutorial/vtune_xpu_timeline.png
+   :width: 100%
+   :align: center
+
+
+The timeline shows the main thread as a `python` thread on the top. Labeled PyTorch operators and customized regions are shown in the main thread row. All operators starting with `aten::` are operators labeled implicitly by the ITT feature in PyTorch. The timeline also shows the GPU Computing Queue on the top, and users could see different XPU Kernels dispatched into GPU Queue.
+
 A short sample code showcasing how to use PyTorch ITT APIs
 ----------------------------------------------------------
 
@@ -128,8 +154,12 @@ The topology is formed by two operators, `Conv2d` and `Linear`. Three iterations
        return x
    
    def main():
-     m = ITTSample()
+     m = ITTSample
+     # unmark below code for XPU
+     # m = m.to("xpu")
      x = torch.rand(10, 3, 244, 244)
+     # unmark below code for XPU
+     # x = x.to("xpu")
      with torch.autograd.profiler.emit_itt():
        for i in range(3)
          # Labeling a region with pair of range_push and range_pop
diff --git a/recipes_source/ptmobile_recipes_summary.rst b/recipes_source/ptmobile_recipes_summary.rst
index 6cc8f6f751..fdf9f58e43 100644
--- a/recipes_source/ptmobile_recipes_summary.rst
+++ b/recipes_source/ptmobile_recipes_summary.rst
@@ -1,43 +1,10 @@
 Summary of PyTorch Mobile Recipes
 =====================================
 
-.. warning::
-    Note: PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://pytorch.org/executorch-overview>`_, PyTorch’s all-new on-device inference library. You can also review these `ExecuTorch examples <https://github.com/pytorch/executorch/tree/main/examples#readme>`_.
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
 
-This summary provides a top level overview of recipes for PyTorch Mobile to help developers choose which recipes to follow for their PyTorch-powered mobile app development.
+Redirecting in 3 seconds...
 
-Introduction
-----------------
+.. raw:: html
 
-When a PyTorch model is trained or retrained, or when a pre-trained model is available, for mobile deployment, follow the the recipes outlined in this summary so mobile apps can successfully use the model.
-
-Pre-requisites
-----------------
-
-PyTorch 1.6.0 or 1.7.0
-
-(Optional) torchvision 0.6.0 or 0.7.0
-
-For iOS development: Xcode 11 or 12
-
-For Android development: Android Studio 3.5.1 or above (with NDK installed); or Android SDK, NDK, Gradle, JDK.
-
-New Recipes for PyTorch Mobile
---------------------------------
-
-* (Recommended) To fuse a list of PyTorch modules into a single module to reduce the model size before quantization, read the `Fuse Modules recipe <fuse.html>`_.
-
-* (Recommended) To reduce the model size and make it run faster without losing much on accuracy, read the `Quantization Recipe <quantization.html>`_.
-
-* (Must) To convert the model to TorchScipt and (optional) optimize it for mobile apps, read the `Script and Optimize for Mobile Recipe <script_optimized.html>`_.
-
-* (Must for iOS development) To add the model in an iOS project and use PyTorch pod for iOS, read the `Model preparation for iOS Recipe <model_preparation_ios.html>`_.
-
-* (Must for Android development) To add the model in an Android project and use the PyTorch library for Android, read the `Model preparation for Android Recipe <model_preparation_android.html>`_.
-
-
-Learn More
------------------
-
-1. `PyTorch Mobile site <https://pytorch.org/mobile>`_
-2. `PyTorch Mobile Performance Recipes <https://pytorch.org/tutorials/recipes/mobile_perf.html>`_
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/recipes/README.txt b/recipes_source/recipes/README.txt
index ef45bae081..4ed6d351ae 100644
--- a/recipes_source/recipes/README.txt
+++ b/recipes_source/recipes/README.txt
@@ -25,38 +25,22 @@ PyTorch Recipes
          Dynamic Quantization
          https://pytorch.org/tutorials/recipes/recipes/dynamic_quantization.html
 
-7. save_load_across_devices.py
-         Saving and loading models across devices in PyTorch
-         https://pytorch.org/tutorials/recipes/recipes/save_load_across_devices.html
-
-8. saving_and_loading_a_general_checkpoint.py
-         Saving and loading a general checkpoint in PyTorch
-         https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_a_general_checkpoint.html
-
-9. saving_and_loading_models_for_inference.py
-         Saving and loading models for inference in PyTorch
-         https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_models_for_inference.html
-
-10. saving_multiple_models_in_one_file.py
-         Saving and loading multiple models in one file using PyTorch
-         https://pytorch.org/tutorials/recipes/recipes/saving_multiple_models_in_one_file.html
-
-11. warmstarting_model_using_parameters_from_a_different_model.py
+7. warmstarting_model_using_parameters_from_a_different_model.py
          Warmstarting models using parameters from different model
          https://pytorch.org/tutorials/recipes/recipes/warmstarting_model_using_parameters_from_a_different_model.html
 
-12. zeroing_out_gradients.py
+8. zeroing_out_gradients.py
          Zeroing out gradients
          https://pytorch.org/tutorials/recipes/recipes/zeroing_out_gradients.html
 
-13. mobile_perf.py
+9. mobile_perf.py
          PyTorch Mobile Performance Recipes
          https://pytorch.org/tutorials/recipes/mobile_perf.html
 
-14. amp_recipe.py
+10. amp_recipe.py
          Automatic Mixed Precision
          https://pytorch.org/tutorials/recipes/amp_recipe.html
 
-15. regional_compilation.py
+11. regional_compilation.py
 	Reducing torch.compile cold start compilation time with regional compilation
          https://pytorch.org/tutorials/recipes/regional_compilation.html
diff --git a/recipes_source/recipes/profiler_recipe.py b/recipes_source/recipes/profiler_recipe.py
index f35172159b..4d43726e71 100644
--- a/recipes_source/recipes/profiler_recipe.py
+++ b/recipes_source/recipes/profiler_recipe.py
@@ -70,6 +70,7 @@
 #    - ``ProfilerActivity.CPU`` - PyTorch operators, TorchScript functions and
 #      user-defined code labels (see ``record_function`` below);
 #    - ``ProfilerActivity.CUDA`` - on-device CUDA kernels;
+#    - ``ProfilerActivity.XPU`` - on-device XPU kernels;
 # - ``record_shapes`` - whether to record shapes of the operator inputs;
 # - ``profile_memory`` - whether to report amount of memory consumed by
 #   model's Tensors;
@@ -160,17 +161,28 @@
 # Note the occurrence of ``aten::convolution`` twice with different input shapes.
 
 ######################################################################
-# Profiler can also be used to analyze performance of models executed on GPUs:
-
-model = models.resnet18().cuda()
-inputs = torch.randn(5, 3, 224, 224).cuda()
-
-with profile(activities=[
-        ProfilerActivity.CPU, ProfilerActivity.CUDA], record_shapes=True) as prof:
+# Profiler can also be used to analyze performance of models executed on GPUs and XPUs:
+# Users could switch between cpu, cuda and xpu
+if torch.cuda.is_available():
+    device = 'cuda'
+elif torch.xpu.is_available():
+    device = 'xpu'
+else:
+    print('Neither CUDA nor XPU devices are available to demonstrate profiling on acceleration devices')
+    import sys
+    sys.exit(0)
+
+activities = [ProfilerActivity.CPU, ProfilerActivity.CUDA, ProfilerActivity.XPU]
+sort_by_keyword = device + "_time_total"
+
+model = models.resnet18().to(device)
+inputs = torch.randn(5, 3, 224, 224).to(device)
+
+with profile(activities=activities, record_shapes=True) as prof:
     with record_function("model_inference"):
         model(inputs)
 
-print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+print(prof.key_averages().table(sort_by=sort_by_keyword, row_limit=10))
 
 ######################################################################
 # (Note: the first use of CUDA profiling may bring an extra overhead.)
@@ -197,6 +209,36 @@
 #    Self CPU time total: 23.015ms
 #    Self CUDA time total: 11.666ms
 #
+######################################################################
+
+
+######################################################################
+# (Note: the first use of XPU profiling may bring an extra overhead.)
+
+######################################################################
+# The resulting table output (omitting some columns):
+#
+# .. code-block:: sh
+#
+#-------------------------------------------------------  ------------  ------------  ------------  ------------  ------------
+#                                                   Name    Self XPU    Self XPU %     XPU total  XPU time avg    # of Calls
+#  -------------------------------------------------------   ------------  ------------  ------------  ------------  ------------
+#                                        model_inference      0.000us         0.00%       2.567ms       2.567ms             1
+#                                           aten::conv2d      0.000us         0.00%       1.871ms      93.560us            20
+#                                      aten::convolution      0.000us         0.00%       1.871ms      93.560us            20
+#                                     aten::_convolution      0.000us         0.00%       1.871ms      93.560us            20
+#                         aten::convolution_overrideable      1.871ms        72.89%       1.871ms      93.560us            20
+#                                               gen_conv      1.484ms        57.82%       1.484ms      74.216us            20
+#                                       aten::batch_norm      0.000us         0.00%     432.640us      21.632us            20
+#                           aten::_batch_norm_impl_index      0.000us         0.00%     432.640us      21.632us            20
+#                                aten::native_batch_norm      432.640us      16.85%     432.640us      21.632us            20
+#                                           conv_reorder      386.880us      15.07%     386.880us       6.448us            60
+#  -------------------------------------------------------   ------------  ------------  ------------  ------------  ------------
+#  Self CPU time total: 712.486ms
+#  Self XPU time total: 2.567ms
+
+#
+
 
 ######################################################################
 # Note the occurrence of on-device kernels in the output (e.g. ``sgemm_32x32x32_NN``).
@@ -266,17 +308,22 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #
 # Profiling results can be outputted as a ``.json`` trace file:
+# Tracing CUDA or XPU kernels
+# Users could switch between cpu, cuda and xpu
+device = 'cuda'
+
+activities = [ProfilerActivity.CPU, ProfilerActivity.CUDA, ProfilerActivity.XPU]
 
-model = models.resnet18().cuda()
-inputs = torch.randn(5, 3, 224, 224).cuda()
+model = models.resnet18().to(device)
+inputs = torch.randn(5, 3, 224, 224).to(device)
 
-with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA]) as prof:
+with profile(activities=activities) as prof:
     model(inputs)
 
 prof.export_chrome_trace("trace.json")
 
 ######################################################################
-# You can examine the sequence of profiled operators and CUDA kernels
+# You can examine the sequence of profiled operators and CUDA/XPU kernels
 # in Chrome trace viewer (``chrome://tracing``):
 #
 # .. image:: ../../_static/img/trace_img.png
@@ -287,15 +334,16 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #
 # Profiler can be used to analyze Python and TorchScript stack traces:
+sort_by_keyword = "self_" + device + "_time_total"
 
 with profile(
-    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
+    activities=activities,
     with_stack=True,
 ) as prof:
     model(inputs)
 
 # Print aggregated stats
-print(prof.key_averages(group_by_stack_n=5).table(sort_by="self_cuda_time_total", row_limit=2))
+print(prof.key_averages(group_by_stack_n=5).table(sort_by=sort_by_keyword, row_limit=2))
 
 #################################################################################
 # The output might look like this (omitting some columns):
@@ -384,15 +432,17 @@
 # To send the signal to the profiler that the next step has started, call ``prof.step()`` function.
 # The current profiler step is stored in ``prof.step_num``.
 #
-# The following example shows how to use all of the concepts above:
+# The following example shows how to use all of the concepts above for CUDA and XPU Kernels:
+
+sort_by_keyword = "self_" + device + "_time_total"
 
 def trace_handler(p):
-    output = p.key_averages().table(sort_by="self_cuda_time_total", row_limit=10)
+    output = p.key_averages().table(sort_by=sort_by_keyword, row_limit=10)
     print(output)
     p.export_chrome_trace("/tmp/trace_" + str(p.step_num) + ".json")
 
 with profile(
-    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
+    activities=activities,
     schedule=torch.profiler.schedule(
         wait=1,
         warmup=1,
@@ -403,14 +453,12 @@ def trace_handler(p):
         model(inputs)
         p.step()
 
-
 ######################################################################
 # Learn More
 # ----------
 #
 # Take a look at the following recipes/tutorials to continue your learning:
 #
-# -  `PyTorch Benchmark <https://pytorch.org/tutorials/recipes/recipes/benchmark.html>`_
-# -  `PyTorch Profiler with TensorBoard <https://pytorch.org/tutorials/intermediate/tensorboard_profiler_tutorial.html>`_ tutorial
-# -  `Visualizing models, data, and training with TensorBoard <https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html>`_ tutorial
+# - `PyTorch Benchmark <https://pytorch.org/tutorials/recipes/recipes/benchmark.html>`_
+# - `Visualizing models, data, and training with TensorBoard <https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html>`_ tutorial
 #
diff --git a/recipes_source/recipes/save_load_across_devices.py b/recipes_source/recipes/save_load_across_devices.py
deleted file mode 100644
index c59af8821e..0000000000
--- a/recipes_source/recipes/save_load_across_devices.py
+++ /dev/null
@@ -1,181 +0,0 @@
-"""
-Saving and loading models across devices in PyTorch
-===================================================
-
-There may be instances where you want to save and load your neural
-networks across different devices.
-
-Introduction
-------------
-
-Saving and loading models across devices is relatively straightforward
-using PyTorch. In this recipe, we will experiment with saving and
-loading models across CPUs and GPUs.
-
-Setup
------
-
-In order for every code block to run properly in this recipe, you must
-first change the runtime to “GPU” or higher. Once you do, we need to
-install ``torch`` if it isn’t already available.
-
-.. code-block:: sh
-
-   pip install torch
-
-"""
-
-######################################################################
-# Steps
-# -----
-# 
-# 1. Import all necessary libraries for loading our data
-# 2. Define and initialize the neural network
-# 3. Save on a GPU, load on a CPU
-# 4. Save on a GPU, load on a GPU
-# 5. Save on a CPU, load on a GPU
-# 6. Saving and loading ``DataParallel`` models
-# 
-# 1. Import necessary libraries for loading our data
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For this recipe, we will use ``torch`` and its subsidiaries ``torch.nn``
-# and ``torch.optim``.
-# 
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-######################################################################
-# 2. Define and initialize the neural network
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For sake of example, we will create a neural network for training
-# images. To learn more see the Defining a Neural Network recipe.
-# 
-
-class Net(nn.Module):
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(3, 6, 5)
-        self.pool = nn.MaxPool2d(2, 2)
-        self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1 = nn.Linear(16 * 5 * 5, 120)
-        self.fc2 = nn.Linear(120, 84)
-        self.fc3 = nn.Linear(84, 10)
-
-    def forward(self, x):
-        x = self.pool(F.relu(self.conv1(x)))
-        x = self.pool(F.relu(self.conv2(x)))
-        x = x.view(-1, 16 * 5 * 5)
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        x = self.fc3(x)
-        return x
-
-net = Net()
-print(net)
-
-
-######################################################################
-# 3. Save on GPU, Load on CPU
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# When loading a model on a CPU that was trained with a GPU, pass
-# ``torch.device('cpu')`` to the ``map_location`` argument in the
-# ``torch.load()`` function.
-# 
-
-# Specify a path to save to
-PATH = "model.pt"
-
-# Save
-torch.save(net.state_dict(), PATH)
-
-# Load
-device = torch.device('cpu')
-model = Net()
-model.load_state_dict(torch.load(PATH, map_location=device, weights_only=True))
-
-
-######################################################################
-# In this case, the storages underlying the tensors are dynamically
-# remapped to the CPU device using the ``map_location`` argument.
-# 
-# 4. Save on GPU, Load on GPU
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# When loading a model on a GPU that was trained and saved on GPU, simply
-# convert the initialized model to a CUDA optimized model using
-# ``model.to(torch.device('cuda'))``.
-# 
-# Be sure to use the ``.to(torch.device('cuda'))`` function on all model
-# inputs to prepare the data for the model.
-# 
-
-# Save
-torch.save(net.state_dict(), PATH)
-
-# Load
-device = torch.device("cuda")
-model = Net()
-model.load_state_dict(torch.load(PATH))
-model.to(device)
-
-
-######################################################################
-# Note that calling ``my_tensor.to(device)`` returns a new copy of
-# ``my_tensor`` on GPU. It does NOT overwrite ``my_tensor``. Therefore,
-# remember to manually overwrite tensors:
-# ``my_tensor = my_tensor.to(torch.device('cuda'))``.
-# 
-# 5. Save on CPU, Load on GPU
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# When loading a model on a GPU that was trained and saved on CPU, set the
-# ``map_location`` argument in the ``torch.load()`` function to
-# ``cuda:device_id``. This loads the model to a given GPU device.
-# 
-# Be sure to call ``model.to(torch.device('cuda'))`` to convert the
-# model’s parameter tensors to CUDA tensors.
-# 
-# Finally, also be sure to use the ``.to(torch.device('cuda'))`` function
-# on all model inputs to prepare the data for the CUDA optimized model.
-# 
-
-# Save
-torch.save(net.state_dict(), PATH)
-
-# Load
-device = torch.device("cuda")
-model = Net()
-# Choose whatever GPU device number you want
-model.load_state_dict(torch.load(PATH, map_location="cuda:0"))
-# Make sure to call input = input.to(device) on any input tensors that you feed to the model
-model.to(device)
-
-
-######################################################################
-# 6. Saving ``torch.nn.DataParallel`` Models
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# ``torch.nn.DataParallel`` is a model wrapper that enables parallel GPU
-# utilization.
-# 
-# To save a ``DataParallel`` model generically, save the
-# ``model.module.state_dict()``. This way, you have the flexibility to
-# load the model any way you want to any device you want.
-# 
-
-# Save
-torch.save(net.module.state_dict(), PATH)
-
-# Load to whatever device you want
-
-
-######################################################################
-# Congratulations! You have successfully saved and loaded models across
-# devices in PyTorch.
-# 
diff --git a/recipes_source/recipes/save_load_across_devices.rst b/recipes_source/recipes/save_load_across_devices.rst
new file mode 100644
index 0000000000..fbda156220
--- /dev/null
+++ b/recipes_source/recipes/save_load_across_devices.rst
@@ -0,0 +1,10 @@
+Save Load Across Devices
+========================
+
+This tutorial was deprecated. There is a newer tutorial that covers the same topic:  https://pytorch.org/tutorials/beginner/saving_loading_models.html
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/saving_loading_models.html'" />
diff --git a/recipes_source/recipes/saving_and_loading_a_general_checkpoint.py b/recipes_source/recipes/saving_and_loading_a_general_checkpoint.py
deleted file mode 100644
index 8c773a1490..0000000000
--- a/recipes_source/recipes/saving_and_loading_a_general_checkpoint.py
+++ /dev/null
@@ -1,155 +0,0 @@
-"""
-Saving and loading a general checkpoint in PyTorch
-==================================================
-Saving and loading a general checkpoint model for inference or 
-resuming training can be helpful for picking up where you last left off.
-When saving a general checkpoint, you must save more than just the
-model’s state_dict. It is important to also save the optimizer’s
-state_dict, as this contains buffers and parameters that are updated as
-the model trains. Other items that you may want to save are the epoch
-you left off on, the latest recorded training loss, external
-``torch.nn.Embedding`` layers, and more, based on your own algorithm.
-
-Introduction
-------------
-To save multiple checkpoints, you must organize them in a dictionary and
-use ``torch.save()`` to serialize the dictionary. A common PyTorch
-convention is to save these checkpoints using the ``.tar`` file
-extension. To load the items, first initialize the model and optimizer,
-then load the dictionary locally using torch.load(). From here, you can
-easily access the saved items by simply querying the dictionary as you
-would expect.
-
-In this recipe, we will explore how to save and load multiple
-checkpoints.
-
-Setup
------
-Before we begin, we need to install ``torch`` if it isn’t already
-available.
-
-::
-
-   pip install torch
-
-
-"""
-
-
-
-######################################################################
-# Steps
-# -----
-# 
-# 1. Import all necessary libraries for loading our data
-# 2. Define and initialize the neural network
-# 3. Initialize the optimizer
-# 4. Save the general checkpoint
-# 5. Load the general checkpoint
-# 
-# 1. Import necessary libraries for loading our data
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For this recipe, we will use ``torch`` and its subsidiaries ``torch.nn``
-# and ``torch.optim``.
-# 
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-######################################################################
-# 2. Define and initialize the neural network
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For sake of example, we will create a neural network for training
-# images. To learn more see the Defining a Neural Network recipe.
-# 
-
-class Net(nn.Module):
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(3, 6, 5)
-        self.pool = nn.MaxPool2d(2, 2)
-        self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1 = nn.Linear(16 * 5 * 5, 120)
-        self.fc2 = nn.Linear(120, 84)
-        self.fc3 = nn.Linear(84, 10)
-
-    def forward(self, x):
-        x = self.pool(F.relu(self.conv1(x)))
-        x = self.pool(F.relu(self.conv2(x)))
-        x = x.view(-1, 16 * 5 * 5)
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        x = self.fc3(x)
-        return x
-
-net = Net()
-print(net)
-
-
-######################################################################
-# 3. Initialize the optimizer
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# We will use SGD with momentum.
-# 
-
-optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
-
-
-######################################################################
-# 4. Save the general checkpoint
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# Collect all relevant information and build your dictionary.
-# 
-
-# Additional information
-EPOCH = 5
-PATH = "model.pt"
-LOSS = 0.4
-
-torch.save({
-            'epoch': EPOCH,
-            'model_state_dict': net.state_dict(),
-            'optimizer_state_dict': optimizer.state_dict(),
-            'loss': LOSS,
-            }, PATH)
-
-
-######################################################################
-# 5. Load the general checkpoint
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# Remember to first initialize the model and optimizer, then load the
-# dictionary locally.
-# 
-
-model = Net()
-optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
-
-checkpoint = torch.load(PATH, weights_only=True)
-model.load_state_dict(checkpoint['model_state_dict'])
-optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
-epoch = checkpoint['epoch']
-loss = checkpoint['loss']
-
-model.eval()
-# - or -
-model.train()
-
-
-######################################################################
-# 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.
-# 
-# If you wish to resuming training, call ``model.train()`` to ensure these
-# layers are in training mode.
-# 
-# Congratulations! You have successfully saved and loaded a general
-# checkpoint for inference and/or resuming training in PyTorch.
-#
diff --git a/recipes_source/recipes/saving_and_loading_a_general_checkpoint.rst b/recipes_source/recipes/saving_and_loading_a_general_checkpoint.rst
new file mode 100644
index 0000000000..b868c26a6c
--- /dev/null
+++ b/recipes_source/recipes/saving_and_loading_a_general_checkpoint.rst
@@ -0,0 +1,10 @@
+Saving And Loading A General Checkpoint
+=======================================
+
+This tutorial was deprecated. There is a newer tutorial that covers the same topic:  https://pytorch.org/tutorials/beginner/saving_loading_models.html
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/saving_loading_models.html'" />
diff --git a/recipes_source/recipes/saving_and_loading_models_for_inference.py b/recipes_source/recipes/saving_and_loading_models_for_inference.py
deleted file mode 100644
index 7adce2a90b..0000000000
--- a/recipes_source/recipes/saving_and_loading_models_for_inference.py
+++ /dev/null
@@ -1,168 +0,0 @@
-"""
-Saving and loading models for inference in PyTorch
-==================================================
-There are two approaches for saving and loading models for inference in
-PyTorch. The first is saving and loading the ``state_dict``, and the
-second is saving and loading the entire model.
-
-Introduction
-------------
-Saving the model’s ``state_dict`` with the ``torch.save()`` function
-will give you the most flexibility for restoring the model later. This
-is the recommended method for saving models, because it is only really
-necessary to save the trained model’s learned parameters.
-When saving and loading an entire model, you save the entire module
-using Python’s
-`pickle <https://docs.python.org/3/library/pickle.html>`__ module. Using
-this approach yields the most intuitive syntax and involves the least
-amount of code. The disadvantage of this approach is that the serialized
-data is bound to the specific classes and the exact directory structure
-used when the model is saved. The reason for this is because pickle does
-not save the model class itself. Rather, it saves a path to the file
-containing the class, which is used during load time. Because of this,
-your code can break in various ways when used in other projects or after
-refactors.
-In this recipe, we will explore both ways on how to save and load models
-for inference.
-
-Setup
------
-Before we begin, we need to install ``torch`` if it isn’t already
-available.
-
-
-::
-
-   pip install torch
-
-
-"""
-
-
-######################################################################
-# Steps
-# -----
-# 
-# 1. Import all necessary libraries for loading our data
-# 2. Define and initialize the neural network
-# 3. Initialize the optimizer
-# 4. Save and load the model via ``state_dict``
-# 5. Save and load the entire model
-# 
-# 1. Import necessary libraries for loading our data
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For this recipe, we will use ``torch`` and its subsidiaries ``torch.nn``
-# and ``torch.optim``.
-# 
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-######################################################################
-# 2. Define and initialize the neural network
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For sake of example, we will create a neural network for training
-# images. To learn more see the Defining a Neural Network recipe.
-# 
-
-class Net(nn.Module):
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(3, 6, 5)
-        self.pool = nn.MaxPool2d(2, 2)
-        self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1 = nn.Linear(16 * 5 * 5, 120)
-        self.fc2 = nn.Linear(120, 84)
-        self.fc3 = nn.Linear(84, 10)
-
-    def forward(self, x):
-        x = self.pool(F.relu(self.conv1(x)))
-        x = self.pool(F.relu(self.conv2(x)))
-        x = x.view(-1, 16 * 5 * 5)
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        x = self.fc3(x)
-        return x
-
-net = Net()
-print(net)
-
-
-######################################################################
-# 3. Initialize the optimizer
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# We will use SGD with momentum.
-# 
-
-optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
-
-
-######################################################################
-# 4. Save and load the model via ``state_dict``
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# Let’s save and load our model using just ``state_dict``.
-# 
-
-# Specify a path
-PATH = "state_dict_model.pt"
-
-# Save
-torch.save(net.state_dict(), PATH)
-
-# Load
-model = Net()
-model.load_state_dict(torch.load(PATH, weights_only=True))
-model.eval()
-
-
-######################################################################
-# A common PyTorch convention is to save models using either a ``.pt`` or
-# ``.pth`` file extension.
-# 
-# Notice that the ``load_state_dict()`` function takes a dictionary
-# object, NOT a path to a saved object. This means that you must
-# deserialize the saved state_dict before you pass it to the
-# ``load_state_dict()`` function. For example, you CANNOT load using
-# ``model.load_state_dict(PATH)``.
-# 
-# Remember too, 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.
-# 
-# 5. Save and load entire model
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# Now let’s try the same thing with the entire model.
-# 
-
-# Specify a path
-PATH = "entire_model.pt"
-
-# Save
-torch.save(net, PATH)
-
-# Load
-model = torch.load(PATH)
-model.eval()
-
-
-######################################################################
-# Again here, remember that you must call ``model.eval()`` to set dropout and
-# batch normalization layers to evaluation mode before running inference.
-# 
-# Congratulations! You have successfully saved and load models for
-# inference in PyTorch.
-# 
-# Learn More
-# ----------
-# 
-# Take a look at these other recipes to continue your learning:
-# 
-# - `Saving and loading a general checkpoint in PyTorch <https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_a_general_checkpoint.html>`__
-# - `Saving and loading multiple models in one file using PyTorch <https://pytorch.org/tutorials/recipes/recipes/saving_multiple_models_in_one_file.html>`__
diff --git a/recipes_source/recipes/saving_and_loading_models_for_inference.rst b/recipes_source/recipes/saving_and_loading_models_for_inference.rst
new file mode 100644
index 0000000000..19e1405dd8
--- /dev/null
+++ b/recipes_source/recipes/saving_and_loading_models_for_inference.rst
@@ -0,0 +1,10 @@
+Saving And Loading Models For Inference
+=======================================
+
+This tutorial was deprecated. There is a newer tutorial that covers the same topic:  https://pytorch.org/tutorials/beginner/saving_loading_models.html
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/saving_loading_models.html'" />
diff --git a/recipes_source/recipes/saving_multiple_models_in_one_file.py b/recipes_source/recipes/saving_multiple_models_in_one_file.py
deleted file mode 100644
index e938be03b4..0000000000
--- a/recipes_source/recipes/saving_multiple_models_in_one_file.py
+++ /dev/null
@@ -1,154 +0,0 @@
-"""
-Saving and loading multiple models in one file using PyTorch
-============================================================
-Saving and loading multiple models can be helpful for reusing models
-that you have previously trained.
-
-Introduction
-------------
-When saving a model comprised of multiple ``torch.nn.Modules``, such as
-a GAN, a sequence-to-sequence model, or an ensemble of models, you must
-save a dictionary of each model’s state_dict and corresponding
-optimizer. You can also save any other items that may aid you in
-resuming training by simply appending them to the dictionary.
-To load the models, first initialize the models and optimizers, then
-load the dictionary locally using ``torch.load()``. From here, you can
-easily access the saved items by simply querying the dictionary as you
-would expect.
-In this recipe, we will demonstrate how to save multiple models to one
-file using PyTorch.
-
-Setup
------
-Before we begin, we need to install ``torch`` if it isn’t already
-available.
-
-.. code-block:: sh
-
-   pip install torch
-
-"""
-
-
-
-######################################################################
-# Steps
-# -----
-# 
-# 1. Import all necessary libraries for loading our data
-# 2. Define and initialize the neural network
-# 3. Initialize the optimizer
-# 4. Save multiple models
-# 5. Load multiple models
-# 
-# 1. Import necessary libraries for loading our data
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For this recipe, we will use ``torch`` and its subsidiaries ``torch.nn``
-# and ``torch.optim``.
-# 
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-######################################################################
-# 2. Define and initialize the neural network
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# For sake of example, we will create a neural network for training
-# images. To learn more see the Defining a Neural Network recipe. Build
-# two variables for the models to eventually save.
-# 
-
-class Net(nn.Module):
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(3, 6, 5)
-        self.pool = nn.MaxPool2d(2, 2)
-        self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1 = nn.Linear(16 * 5 * 5, 120)
-        self.fc2 = nn.Linear(120, 84)
-        self.fc3 = nn.Linear(84, 10)
-
-    def forward(self, x):
-        x = self.pool(F.relu(self.conv1(x)))
-        x = self.pool(F.relu(self.conv2(x)))
-        x = x.view(-1, 16 * 5 * 5)
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        x = self.fc3(x)
-        return x
-
-netA = Net()
-netB = Net()
-
-
-######################################################################
-# 3. Initialize the optimizer
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# We will use SGD with momentum to build an optimizer for each model we
-# created.
-# 
-
-optimizerA = optim.SGD(netA.parameters(), lr=0.001, momentum=0.9)
-optimizerB = optim.SGD(netB.parameters(), lr=0.001, momentum=0.9)
-
-
-######################################################################
-# 4. Save multiple models
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# Collect all relevant information and build your dictionary.
-# 
-
-# Specify a path to save to
-PATH = "model.pt"
-
-torch.save({
-            'modelA_state_dict': netA.state_dict(),
-            'modelB_state_dict': netB.state_dict(),
-            'optimizerA_state_dict': optimizerA.state_dict(),
-            'optimizerB_state_dict': optimizerB.state_dict(),
-            }, PATH)
-
-
-######################################################################
-# 4. Load multiple models
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# Remember to first initialize the models and optimizers, then load the
-# dictionary locally.
-# 
-
-modelA = Net()
-modelB = Net()
-optimModelA = optim.SGD(modelA.parameters(), lr=0.001, momentum=0.9)
-optimModelB = optim.SGD(modelB.parameters(), lr=0.001, momentum=0.9)
-
-checkpoint = torch.load(PATH, weights_only=True)
-modelA.load_state_dict(checkpoint['modelA_state_dict'])
-modelB.load_state_dict(checkpoint['modelB_state_dict'])
-optimizerA.load_state_dict(checkpoint['optimizerA_state_dict'])
-optimizerB.load_state_dict(checkpoint['optimizerB_state_dict'])
-
-modelA.eval()
-modelB.eval()
-# - or -
-modelA.train()
-modelB.train()
-
-
-######################################################################
-# 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.
-# 
-# If you wish to resuming training, call ``model.train()`` to ensure these
-# layers are in training mode.
-# 
-# Congratulations! You have successfully saved and loaded multiple models
-# in PyTorch.
-#
diff --git a/recipes_source/recipes/saving_multiple_models_in_one_file.rst b/recipes_source/recipes/saving_multiple_models_in_one_file.rst
new file mode 100644
index 0000000000..33040e6c87
--- /dev/null
+++ b/recipes_source/recipes/saving_multiple_models_in_one_file.rst
@@ -0,0 +1,10 @@
+Saving Multiple Models In One File
+==================================
+
+This tutorial was deprecated. There is a newer tutorial that covers the same topic:  https://pytorch.org/tutorials/beginner/saving_loading_models.html
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/beginner/saving_loading_models.html'" />
diff --git a/recipes_source/script_optimized.rst b/recipes_source/script_optimized.rst
index f4384b1a3a..ed64419ff4 100644
--- a/recipes_source/script_optimized.rst
+++ b/recipes_source/script_optimized.rst
@@ -1,218 +1,11 @@
 Script and Optimize for Mobile Recipe
 =====================================
 
-This recipe demonstrates how to convert a PyTorch model to TorchScript which can run in a high-performance C++ environment such as iOS and Android, and how to optimize the converted TorchScript model for mobile deployment.
+This tutorial has been deprecated. There is a new tutorial on this topic.
 
-Introduction
-------------
+Redirecting in 3 seconds...
 
-After a PyTorch model is trained and optionally but preferably quantized (see `Quantization Recipe <quantization.html>`_ for more details), one essential step before the model can be used in iOS and Android apps is to convert the Python-dependent model to TorchScript, which can then further be optimized for mobile apps. Conversion to TorchScript can be as simple as a single call, or as complicated as changing the original model in many different places.
+.. raw:: html
 
-Pre-requisites
---------------
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/tutorials/export-to-executorch-tutorial.html'" />
 
-PyTorch 1.6.0 or 1.7.0
-
-Conversion to TorchScript
--------------------------
-
-There are two basic ways to convert a PyTorch model to TorchScript, using `trace` and `script`. Mixing `trace` and `script` may also be needed in some cases - see `here <https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html#mixing-scripting-and-tracing>`_ for more information.
-
-Use the `trace` Method
-^^^^^^^^^^^^^^^^^^^^^^
-
-To use the `trace` method on a model, an example or dummy input for the model needs to be specified, the actual input size needs to be the same as the example input size, and the model definition cannot have control flow such as `if` or `for`. The reason for these constraints is that running `trace` on a model with an example input simply calls the model's `forward` method with the input and all operations executed in the model layers are recorded, creating the trace of the model.
-
-::
-
-    import torch
-
-    dummy_input = torch.rand(1, 3, 224, 224)
-    torchscript_model = torch.jit.trace(model_quantized, dummy_input)
-
-
-Use the `script` Method
-^^^^^^^^^^^^^^^^^^^^^^^
-
-For the example above, calling `script` below makes no difference:
-
-::
-
-    torchscript_model = torch.jit.script(model_quantized)
-
-But if a model has some flow control, then `trace` won't correctly record all the possible traces. Take some code snippet of an example model definition from `here <https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html>`_ for example:
-
-::
-
-    import torch
-
-    class MyDecisionGate(torch.nn.Module):
-        def forward(self, x):
-            if x.sum() > 0:
-                return x
-            else:
-                return -x
-
-    x = torch.rand(3, 4)
-    traced_cell = torch.jit.trace(MyDecisionGate(), x)
-    print(traced_cell.code)
-
-The code above will output:
-
-::
-
-    TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can''t record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!
-
-    if x.sum() > 0:
-  def forward(self,
-      x: Tensor) -> Tensor:
-    return x
-
-
-Note that "the trace might not generalize to other inputs" warning above means that if the model has any kind of data-dependent control flow, `trace` is not the right answer. But if we replace the last two lines of the Python code snippet above (before the code output) with:
-
-::
-
-    scripted_cell = torch.jit.script(MyDecisionGate())
-    print(scripted_cell.code)
-
-The scripted model as shown by the `print` result below will be covering all possible inputs, thus generalizing to other inputs:
-
-::
-
-    def forward(self,
-        x: Tensor) -> Tensor:
-      _0 = bool(torch.gt(torch.sum(x, dtype=None), 0))
-      if _0:
-        _1 = x
-      else:
-        _1 = torch.neg(x)
-      return _1
-
-
-This is another example of using `trace` and `script` - it converts the model trained in the PyTorch tutorial `NLP FROM SCRATCH: TRANSLATION WITH A SEQUENCE TO SEQUENCE NETWORK AND ATTENTION <https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html>`_:
-
-::
-
-    encoder = EncoderRNN(input_lang.n_words, hidden_size)
-    decoder = AttnDecoderRNN(hidden_size, output_lang.n_words)
-
-    # method 1: using trace with example inputs
-
-    encoder_input=torch.tensor([1])
-    encoder_hidden=torch.zeros(1, 1, hidden_size)
-
-    decoder_input1=torch.tensor([[0]])
-    decoder_input2=torch.zeros(1, 1, hidden_size)
-    decoder_input3=torch.zeros(MAX_LENGTH, hidden_size)
-
-    traced_encoder = torch.jit.trace(encoder, (encoder_input, encoder_hidden))
-    traced_decoder = torch.jit.trace(decoder, (decoder_input1, decoder_input2, decoder_input3))
-
-    # method 2: using script
-
-    scripted_encoder = torch.jit.script(encoder)
-    scripted_decoder = torch.jit.script(decoder)
-
-So is it true that one can simply always use the `script` call and the model is converted to TorchScript? The answer is no, because TorchScript is actually a subset of Python and to make `script` work, the PyTorch model definition must only use the language features of that TorchScript subset of Python. `TorchScript Language Reference <https://pytorch.org/docs/master/jit_language_reference.html#language-reference>`_ covers all the details of what is supported in TorchScript. Below we will describe some of the common errors when using the `script` method.
-
-
-Fix Common Errors When Using the `script` Method
-----------------------------------------------------
-
-If you apply the `script` method to a non-trivial model, chances are you may encounter several types of errors. Check out `this tutorial <https://pytorch.org/tutorials/beginner/deploy_seq2seq_hybrid_frontend_tutorial.html>`_ for a complete example of converting a chatbot model to TorchScript. But follow the steps below to fix common errors when you run the `script` method:
-
-1. RuntimeError `attribute lookup is not defined on python value of type`
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-For this error, pass the value of the model as a parameter in the constructor. This is because when calling `script` on a model that accepts another model as a parameter, the model passed is actually of type `TracedModule` or `ScriptModule`, not of type `Module`, making the the model attribute not defined when scripting.
-
-For example, the `LuongAttnDecoderRNN` module in the tutorial above has an attribute `n_layers`, and the `GreedySearchDecoder` module refers to the `n_layers` attribute of a `decoder` instance of the `LuongAttnDecoderRNN` module, so in order to make `script` work, the `GreedySearchDecoder` module's constructor needs to be changed from:
-
-::
-
-    def __init__(self, encoder, decoder):
-
-to:
-
-::
-
-    def __init__(self, encoder, decoder, decoder_n_layers):
-      ...
-      self._decoder_n_layers = decoder_n_layers
-
-
-and the `GreedySearchDecoder`'s `forward` method needs to refer `self._decoder_n_layers` instead of `decoder.n_layers`.
-
-2. RuntimeError `python value of type '...' cannot be used as a value.`
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The complete error message for this one continues with `Perhaps it is a closed over global variable? If so, please consider passing it in as an argument or use a local variable instead.`, store global variables' values as attributes in the model constructor (there's no need to add them to a special list called `__constants__`). The reason is that global values can be used conveniently in normal model training and inference, but the global values are not accessible during the scripting.
-
-For example, `device` and `SOS_token` are global variables, and to make `script` work, they need to be added to the `GreedySearchDecoder`'s constructor:
-
-::
-
-    self._device = device
-    self._SOS_token = SOS_token
-
-and referred to as `self._device` and `self._SOS_token` instead of `device` and `SOS_token` in the `GreedySearchDecoder`'s `forward` method.
-
-3. RuntimeError `all inputs of range must be '...', found Tensor (inferred) in argument`
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The error message continues with: `add type definitions for each of the module's forward method arguments. Because all parameters to a TorchScript function are of the `torch.Tensor` type by default, you need to specifically declare the type for each parameter that is not of type 'Tensor'. For a complete list of TorchScript-supported types, see `here <https://pytorch.org/docs/master/jit_language_reference.html#supported-type>`_.
-
-For example, the `GreedySearchDecoder`'s `forward` method signature needs to be changed from:
-
-::
-
-    def forward(self, input_seq, input_length, max_length):
-
-to:
-
-::
-
-    def forward(self, input_seq, input_length, max_length : int):
-
-After using the `trace` or `script` method above, and fixing possible errors, you should have a TorchScript model ready to be optimized for mobile.
-
-
-Optimize a TorchScript Model
---------------------------------------
-
-Simply run the following code snippet to optimize a TorchScript model generated with the `trace` and/or `script` method:
-
-::
-
-    from torch.utils.mobile_optimizer import optimize_for_mobile
-    optimized_torchscript_model = optimize_for_mobile(torchscript_model)
-
-The optimized model can then be saved and deployed in mobile apps:
-
-::
-
-    optimized_torchscript_model.save("optimized_torchscript_model.pth")
-
-By default, for the CPU backend, `optimize_for_mobile` performs the following types of optimizations:
-
-* `Conv2D and BatchNorm fusion` which folds Conv2d-BatchNorm2d into Conv2d;
-
-* `Insert and fold prepacked ops` which rewrites the model graph to replace 2D convolutions and linear ops with their prepacked counterparts.
-
-* `ReLU and hardtanh fusion` which rewrites graph by finding ReLU/hardtanh ops and fuses them together.
-
-* `Dropout removal` which removes dropout nodes from this module when training is false.
-
-* `Conv packed params hoisting` which moves convolution packed params to the root module, so that the convolution structs can be deleted. This decreases model size without impacting numerics.
-
-For the Vulkan backend,`optimize_for_mobile` performs the following type of optimization:
-
-* `Automatic GPU transfer` which rewrites the graph so that moving input and output data to and from the GPU becomes part of the model.
-
-Optimization types can be disabled by passing an optimization blocklist as an argument to `optimize_for_mobile`.
-
-Learn More
------------------
-1. The official `TorchScript Language Reference <https://pytorch.org/docs/stable/jit_language_reference.html>`_.
-2. The `torch.utils.mobile_optimizer` `API documentation <https://pytorch.org/docs/stable/mobile_optimizer.html>`_.
diff --git a/recipes_source/torchscript_inference.rst b/recipes_source/torchscript_inference.rst
index 54068e7072..8aa606fd0d 100644
--- a/recipes_source/torchscript_inference.rst
+++ b/recipes_source/torchscript_inference.rst
@@ -1,6 +1,8 @@
 TorchScript for Deployment
 ==========================
 
+.. note:: TorchScript is no longer in active development.
+
 In this recipe, you will learn:
 
 -  What TorchScript is